暑期集训day1例题（最短路径、二分图匹配、拓扑排序）

poj 3259

题意：F组数据，N块地之间有M条路、W个虫洞。给了两块地之间的行走时间，两块地之间的虫洞能回到t秒前，问农夫能否看到自己的背影。

思路：记录处理两块地之间的边，判断是否存在负权环。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;

const int maxn = 500 + 5;
const int INF = 0x3f3f3f3f;
int n,m,w,s,e,t;
int pic[maxn][maxn];

int floyd()
{
    for(int i = 1; i <= n; i++)
    for(int j = 1; j <= n; j++){
        for(int k = 1; k <= n; k++)
            if(pic[j][k] > pic[j][i] + pic[i][k])
                pic[j][k] = pic[j][i] + pic[i][k];
        if(pic[j][j] < 0) return 1;
    }
    return 0;
}

int main()
{
    int f;
    scanf("%d",&f);
    while(f--){
        scanf("%d%d%d",&n,&m,&w);

        for(int i = 0 ; i < maxn; i++)//初始化每块地之间需要INF秒
            for(int j = 0; j < maxn; j++)
                pic[i][j] = INF;

        for(int i = 0; i < m; i++){//两块地之间需要花费t秒
            scanf("%d%d%d",&s,&e,&t);
            if(t < pic[s][e]) pic[s][e] = pic[e][s] = t;
        }
        for(int i = 0; i < w; i++){//从s到e的虫洞能使时间回到t秒前
            scanf("%d%d%d",&s,&e,&t);
            pic[s][e] = -t;
        }
        for(int i = 0; i < n; i++)//到自己本身不用花时间
            pic[i][i] = 0;

        int res = floyd();//找是否存在负权环
        if(res) printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}

反思：这题很简单，我却调了很久。第一，数组下标问题，想清楚从零还是从一开始的。第二，INF原本写的太小，WA了一次。一般是直接写0x3f3f3f3f，若大到用 long long，就设成0x3f3f3f3f3f3f3f3fLL。

poj 3041

题意：N*N的格子里，有K个小行星。每次只能除去一行或者一列的小行星，问至少需要几次才能清除完。

思路：把每个x，y看做这两个集合中的点，小行星的坐标看做连接x，y的边，问题就变成清除完所有的边，即 找二分图的最小点覆盖问题（二分图中，选取最少的点数，使这些点把所有的边都覆盖，叫做最小点覆盖）。根据定理，最小点覆盖数=最大匹配数。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

const int maxn = 500 + 5;
const int maxnn = 10000 + 5;
int n,m,r,c;
int line[maxn][maxn];
int used[maxnn],match[maxnn];

bool path(int x)//遍历每个y，看能否找到能匹配x的
{
    for(int i = 1; i <= n; i++){
        if(line[x][i] && !used[i]){//如果相连且没有试图找过
            used[i] = 1;
            if(!match[i] || path(match[i])){
            //没人和它匹配或可以递归让别人换个方案而匹配的
                match[i] = x;
                return true;
            }
        }
    }
    return false;
}

int main()
{
    while(~scanf("%d%d",&n,&k)){
        int ans = 0;
        memset(line,0,sizeof(line));
        memset(match,0,sizeof(match));
        for(int i = 0; i < k; i++){//使小行星的x,y相连
            scanf("%d%d",&r,&c);
            line[r][c] = 1;
        }

        for(int i = 1; i <= n; i++){//遍历每个小行星的x
            memset(used,0,sizeof(used));
            if(path(i)) ans++;
        }
        printf("%d\n",ans);
    }
}

poj 1094

题意：给定N（2<=N<=26）个英文字母，从第一个到第N个。给定M个关系，给定字母间大小关系（偏序关系）。要求及时给出确定的唯一的全序关系。
输出有三个种：
得到确定的拓扑序列的时间（字母序列唯一有序）
发现矛盾的时间（序列中有环）
不能判断是否有序（不能得到从A到第N个字母的拓扑序列）

思路：需要注意的点就是要判断序列中是否有环，在每次循环判断入度时，如果没有入度为0的点，则序列有环。如果入度为零的点大于一个，则没有确定的拓扑序列。找到每个入度为零的点，存到数组中，并把关联的点的入度减一。用一个标记来记录是否有解与序列是否有环，剩下的情况就是不能判断的情况。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;

const int maxn = 26 + 5;
int n,m;
int pic[maxn][maxn];
int in[maxn], q[maxn];

int TopoSort(int n)//拓扑排序
{
    int c = 0, tmp[maxn],loc,m,flag = 1;
    for(int i = 1; i <= n; i++)
        tmp[i] = in[i];
    for(int i = 1; i <= n; i++){
        m = 0;
        for(int j = 1; j <= n; j++)
            if(tmp[j] == 0){//查找入度为零的顶点个数
                m++;
                loc = j;
            }
        if(m == 0) return 0; //有环
        else if(m > 1) flag = -1; //无序
        q[c++] = loc;
        tmp[loc] = -1;//去掉loc
        for(int j = 1; j <= n; j++)//去掉loc的边，即loc指向的点入度减一
            if(pic[loc][j] == 1) tmp[j]--;
    }
    return flag;
}

int main()
{
    char s[5];
    while(~scanf("%d%d",&n,&m)){
        if(n == 0 && m == 0) break;
        memset(pic,0,sizeof(pic));
        memset(in,0,sizeof(in));
        int flag = 0;
        for(int i = 1; i <= m; i++){
            scanf("%s",&s);
            if(flag) continue; //已有结果，不做处理
            int x = s[0]-'A'+1;
            int y = s[2]-'A'+1;
            pic[x][y] = 1;
            in[y]++;
            int p = TopoSort(n);
            if(p == 0){//有环
                printf("Inconsistency found after %d relations.\n",i);
                flag = 1;
            }
            else if(p == 1){//有序
                printf("Sorted sequence determined after %d relations: ",i);
                for(int j = 0; j < n; j++)
                    printf("%c",q[j]+'A'-1);
                printf(".\n");
                flag = 1;
            }
        }
        if(!flag)//不确定
            printf("Sorted sequence cannot be determined.\n");
    }
    return 0;
}