拓扑排序 及 练习
4-25 号和熊神商定开始搞图论，自然从基础开始学习，这两天把自己以前一直很有疑惑的一个基础算法搞懂了：拓扑排序。
用的模板是acdream的链式前向星结构，但是看到教主们 都用的是领接表，没有认真研究过两者差别，TUT
先贴上模板：
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<iostream>
#include<math.h>
using namespace std;
const int N = 10005;
bool vis[N];
int head[N],degree[N];
int Q[N],cnt,num;
int f[N]; //分层图
struct EdgeNode
{
int to;
int next;
};
EdgeNode Edge[N];
void Init()
{
cnt = 0;
memset(vis,false,sizeof(vis));
memset(head,-1,sizeof(head));
memset(degree,0,sizeof(degree));
memset(f,0,sizeof(f));
}
void add(int u,int v)
{
degree[v]++;
Edge[cnt].to = v;
Edge[cnt].next = head[u]; //即存以u为开头的上一条边的编号，方便下方遍历
head[u] = cnt++; // 记录这一条以u为开头的边
}
void TopSort(int n)
{
num = 0;
for(int i=1;i<=n;i++) //先将没有前驱的节点加入队列
if(!degree[i]&&vis[i]){ //在某些情况，不需要在连通分量里
Q[num++] = i;
f[i]=1;
}
for(int i=0;i<num;i++)
{
//删除从该节点出发的所有边，更新degree数组
for(int k = head[Q[i]];k != -1;k = Edge[k].next)
{
degree[Edge[k].to]--;
//如果degree数组为0，说明新的没有前驱的节点找到,加入队列中
if(!degree[Edge[k].to]){
Q[num++] = Edge[k].to;
f[Edge[k].to]=f[Q[i]]+1;
}
}
}
}
int main()
{
int n,m;
while(~scanf("%d %d",&n,&m))
{
Init();
while(m--)
{
int sta,to;
cin>>sta>>to;
vis[sta] = true;
vis[to] = true;
add(sta,to);
}
TopSort(n);
for(int i=0;i<num;i++)
cout<<Q[i]<<" ";
cout<<endl;
}
return 0;
}在别人的模板上我自己增加了一个分层图f，便于自己做一些操作
这几天做的题目：
Hdu 1285 ，水题 直接v*v 就好了，用不到链式结构
Hdu 2647 ，刚开始像sb一顿乱搞一通， 实际上我们只要反向建图就可以很轻松的完成这个题目，这种反向建图的方法好像就是叫逆拓扑排序。
Hdu3342 理解为 判断有向图是否存在环，即可。水题
Codeforces #290 div2 C. Fox And Names
拓扑排序：先建立1-26 个点代表a-z，每两个串之间可以建立一条边，或者不建立边（比如a和 ab， absc和abscc） 然后跑一遍拓扑排序，分一下层，把所有独立点放到第一层，然后逐层输出即可。
有一个坑点： 如果存在（aaa，aa） 这种情况是impossible，因为这种数据是不合题意的，在字典序相同的情况之下应该按短的在前面。
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<iostream>
#include<math.h>
using namespace std;
const int N = 10005;
bool vis[N];
int head[N],degree[N];
int Q[N],cnt,num;
char str[105][110];
int f[N];
struct EdgeNode
{
int to;
int next;
};
EdgeNode Edge[N];
void Init()
{
cnt = 0;
memset(vis,false,sizeof(vis));
memset(head,-1,sizeof(head));
memset(degree,0,sizeof(degree));
memset(f,0,sizeof(f));
}
void add(int u,int v)
{
degree[v]++;
Edge[cnt].to = v;
Edge[cnt].next = head[u]; //即存以u为开头的上一条边的编号，方便下方遍历
head[u] = cnt++; // 记录这一条以u为开头的边
}
void TopSort(int n)
{
num = 0;
for(int i=1;i<=n;i++) //先将没有前驱的节点加入队列
if(!degree[i]){ //在某些情况，不需要在连通分量里
Q[num++] = i;
f[i]=1;
}
for(int i=0;i<num;i++)
{
//删除从该节点出发的所有边，更新degree数组
for(int k = head[Q[i]];k != -1;k = Edge[k].next)
{
degree[Edge[k].to]--;
//如果degree数组为0，说明新的没有前驱的节点找到,加入队列中
if(!degree[Edge[k].to]){
Q[num++] = Edge[k].to;
f[Edge[k].to]=f[Q[i]] + 1;
}
}
}
}
int main()
{
int n,nn;
// freopen("1.txt","r",stdin);
while(~scanf("%d",&nn)){
Init();
n=26;
int flag=1;
for(int i=1;i<=nn;i++)
scanf("%s",str[i]);
for(int i=1;i<nn;i++){
int pos=0;
// cout<<str[i][pos] << " "<<str[i+1][pos]<<endl;
while(str[i][pos]==str[i+1][pos] && pos<strlen(str[i]) && pos<strlen(str[i+1])){
// cout<<str[i][pos] << " "<<str[i+1][pos]<<endl;
pos++;
}
if(pos==strlen(str[i+1]) && pos<strlen(str[i]) ){
flag=0;
break;
}
if(pos==strlen(str[i]) )
continue;
int sta,to;
sta=str[i][pos]-'a'+1;
to=str[i+1][pos]-'a'+1;
vis[sta]=vis[to]=1;
add(sta,to);
}
TopSort(n);
// for(int i=0;i<n;i++)
// printf("%d ",degree[i]);
// cout<<endl;
if(flag==0){
printf("Impossible\n");
continue;
}
for(int i=0;i<n;i++){
if(degree[i]){
printf("Impossible\n");
flag=0;
break;
}
}
if(flag){
for(int i=1;i<105;i++){
for(int j=1;j<=n;j++)
if(f[j]==i){
printf("%c",j+'a'-1);
}
}
cout<<endl;
}
}
return 0;
}Codeforces #645 D Robot Rapping Results Report
没有坑点，如果只用拓扑排序会超时，但是只需要加个二分就很轻松的过了。
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<iostream>
#include<math.h>
using namespace std;
const int N = 100005;
bool vis[N];
int head[N],degree[N];
int Q[N],cnt,num;
int f[N]; //分层
int flag[N];
struct EdgeNode
{
int to;
int next;
};
EdgeNode Edge[N];
void Init()
{
cnt = 0;
memset(vis,false,sizeof(vis));
memset(head,-1,sizeof(head));
memset(degree,0,sizeof(degree));
memset(f,0,sizeof(f));
memset(flag,0,sizeof(flag));
}
void add(int u,int v)
{
degree[v]++;
Edge[cnt].to = v;
Edge[cnt].next = head[u]; //即存以u为开头的上一条边的编号，方便下方遍历
head[u] = cnt++; // 记录这一条以u为开头的边
}
void TopSort(int n)
{
num = 0;
for(int i=1;i<=n;i++) //先将没有前驱的节点加入队列
if(!degree[i]&&vis[i]){ //在某些情况，不需要在连通分量里
Q[num++] = i;
f[i]=1;
}
for(int i=0;i<num;i++)
{
//删除从该节点出发的所有边，更新degree数组
for(int k = head[Q[i]];k != -1;k = Edge[k].next)
{
degree[Edge[k].to]--;
//如果degree数组为0，说明新的没有前驱的节点找到,加入队列中
if(!degree[Edge[k].to]){
Q[num++] = Edge[k].to;
f[Edge[k].to]=f[Q[i]]+1;
}
}
}
}
int sta[100005],to[100005];
int jud(int n){
int ans=1;
for(int i=1;i<=n;i++){
if(!f[i]){
ans=0;
break;
}
if(flag[f[i]]==0)
flag[f[i]]++;
else if(flag[f[i]]>0){
ans=0;
break;
}
}
return ans;
}
int main()
{
//freopen("1.txt","r",stdin);
int n,m;
while(~scanf("%d %d",&n,&m))
{
Init();
for(int i=1;i<=m;i++){
int u,v;
cin>>u>>v;
sta[i] = u;
to[i] = v;
add(u,v);
vis[u]=vis[v]=1;
}
TopSort(n);
if(jud(n)==0){
printf("-1\n");
continue;
}
int loww=1,highh=m;
while(loww<highh ){
Init();
int mid=(loww+highh)/2;
for(int i=1;i<=mid;i++){
vis[sta[i]]=vis[to[i]]=1;
add(sta[i],to[i]);
}
TopSort(n);
int ans=jud(n);
if(ans==1){
highh=mid;
}
else
loww=mid+1;
}
printf("%d\n",loww);
}
return 0;
}Codeforces Round #292 (Div. 2) D. Drazil and Tiles
这个题 先建图，点与点之间的图，如果成环必然不独特（但是如果有:
*. .
. . .
这种情况下是不成环的，然后找度为1 的点 拓扑排序弄出来就好，代码我写的很长，而且我交的时候题目数据损坏，暂时交不了，过几天再交试试：
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<iostream>
#include<math.h>
using namespace std;
const int N = 4000005;
bool vis[N];
int head[N],degree[N];
int Q[N],cnt,num;
int f[N]; //分层图
int tem=1;
char mp[2005][2005];
struct EdgeNode
{
int to;
int next;
};
EdgeNode Edge[N];
void Init()
{
cnt = 0;
memset(vis,false,sizeof(vis));
memset(head,-1,sizeof(head));
memset(degree,0,sizeof(degree));
memset(f,0,sizeof(f));
memset(mp,0,sizeof(mp));
}
void add(int u,int v)
{
degree[v]++;
Edge[cnt].to = v;
Edge[cnt].next = head[u]; //即存以u为开头的上一条边的编号，方便下方遍历
head[u] = cnt++; // 记录这一条以u为开头的边
}
void TopSort(int n)
{
num = 0;
for(int i=1;i<=tem;i++) //先将没有前驱的节点加入队列
if(degree[i]==1){ //在某些情况，不需要在连通分量里
Q[num++] = i;
// printf("%d\n",i);
f[i]=1;
}
for(int i=0;i<num;i++)
{
//删除从该节点出发的所有边，更新degree数组
for(int k = head[Q[i]];k != -1;k = Edge[k].next)
{
if(f[Q[i]]==1){
degree[Edge[k].to]=1;
f[Edge[k].to]=2;
Q[num++] = Edge[k].to;
continue;
}
degree[Edge[k].to]--;
//如果degree数组为0，说明新的没有前驱的节点找到,加入队列中
if(degree[Edge[k].to] ==1 ){
Q[num++] = Edge[k].to;
f[Edge[k].to]=1;
}
}
}
}
int n,m;
void work(int pos){
int y=pos%m;
int x=pos/m +1;
if(y==0){
y=m;
x--;
}
if(mp[x][y]!='.')
return;
if(mp[x+1][y]=='.') mp[x][y]='^',mp[x+1][y]='v';
if(mp[x-1][y]=='.') mp[x][y]='v',mp[x-1][y]='^';
if(mp[x][y+1]=='.') mp[x][y]='<',mp[x][y+1]='>';
if(mp[x][y-1]=='.') mp[x][y]='>',mp[x][y-1]='<';
}
int pos(int x,int y){
return (x-1)*m+y;
}
int main()
{
freopen("1.txt","r",stdin);
while(~scanf("%d %d",&n,&m))
{
Init();
for(int i=1;i<=n;i++)
scanf("%s",mp[i]+1);
tem=n*m;
int get=0;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++){
if(mp[i][j]=='.'){
get++;
}
tem++;
}
if(get%2){
printf("Not unique\n");
continue;
}
tem--;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++){
if(mp[i][j]=='.'){
if(mp[i-1][j]=='.') add(pos(i,j),pos(i-1,j));
if(mp[i+1][j]=='.') add(pos(i,j),pos(i+1,j));
if(mp[i][j-1]=='.') add(pos(i,j),pos(i,j-1));
if(mp[i][j+1]=='.') add(pos(i,j),pos(i,j+1));
}
}
TopSort(tem);
int flag=1;
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if(mp[i][j]=='.'){
if(mp[i+1][j]!='.' &&mp[i-1][j]!='.' &&mp[i][j+1]!='.' &&mp[i][j-1]!='.'){
flag=0;
break;
}
if(degree[pos(i,j)]>1){
// printf("%d %d %d\n",i,j,degree[pos(i,j)]);
flag=0;
break;
}
}
if(flag==0){
printf("Not unique\n");
continue;
}
for(int i=0;i<num;i++){
int ff=Q[i];
work(ff);
}
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++)
cout<<mp[i][j];
cout<<endl;
}
}
return 0;
}