{white5}

接着紫书图论开始刷。。。

Fire!

 UVA - 11624 

先从所有火源bfs1求出任意方格的起火时间，再从人开始bfs2逃跑。

#include <bits/stdc++.h>
using namespace std;
const int maxn=1050;
char pic[maxn][maxn];
int vis[maxn][maxn];
int dead[maxn][maxn];
int n,m;
int dir[4][2]={0,1,0,-1,1,0,-1,0};
struct node
{
    int x,y;
    int st;
    node(int x=0,int y=0,int st=0):x(x),y(y),st(st){}
}now,nex;

queue<node>q;
bool inside(node no)
{
    if(no.x>=0&&no.x<n&&no.y>=0&&no.y<m) return 1;
    return 0;
}
void bfs1()
{
    memset(vis,0,sizeof(vis));
    while(!q.empty()) q.pop();
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
        {
            dead[i][j]=0x3f3f3f3f;
            if(pic[i][j]=='F')
            {
                q.push(node(i,j,0));
                dead[i][j]=0;
                vis[i][j]=1;
            }

        }
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        for(int i=0;i<4;i++)
        {
            nex.x=now.x+dir[i][0];
            nex.y=now.y+dir[i][1];
            if(inside(nex)&&!vis[nex.x][nex.y]&&pic[nex.x][nex.y]!='#')
            {
                vis[nex.x][nex.y]=1;
                dead[nex.x][nex.y]=dead[now.x][now.y]+1;
                q.push(nex);
            }
        }

    }
    return ;
}
int bfs2()
{
    while(!q.empty()) q.pop();
    memset(vis,0,sizeof(vis));
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
    if(pic[i][j]=='J')  {
        q.push(node(i,j,0));
        vis[i][j]=1;
        break;
    }
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        if(now.x==0||now.x==n-1||now.y==0||now.y==m-1) return now.st+1;
        for(int i=0;i<4;i++)
        {
            nex.x=now.x+dir[i][0];
            nex.y=now.y+dir[i][1];
            nex.st=now.st+1;
            if(inside(nex)&&!vis[nex.x][nex.y]&&pic[nex.x][nex.y]!='#'&&nex.st<dead[nex.x][nex.y])
            {
                vis[nex.x][nex.y]=1;
                q.push(nex);
            }
        }
    }
    return -1;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        for(int i=0;i<n;i++)
                scanf("%s",pic[i]);
        bfs1();
        int ans=bfs2();
        if(ans!=-1) printf("%d
",ans);
        else puts("IMPOSSIBLE");
    }
}

The Monocycle

 UVA - 10047 

 其实只是简单的一个bfs

因为一点小错误搞了很久，代码也写得很拉杂。。。

看到别人代码vis数组可以省去，dis可以直接放结构体里方便些

#include <bits/stdc++.h>
using namespace std;
const int maxn=30;
const int inf=0x3f3f3f3f;
int d[maxn][maxn][4][5];
int vis[maxn][maxn][4][5];
int dir[4][2]={-1,0,0,1,1,0,0,-1};
char g[maxn][maxn];
int n,m;
int sx,sy,ex,ey;
struct node
{
    int x,y,d,c;
    node(int x=0,int y=0,int d=0,int c=0):x(x),y(y),d(d),c(c){}
};
int bfs()
{
    queue<node> q;
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
        for(int k=0;k<4;k++)
        for(int l=0;l<5;l++)
    {
        d[i][j][k][l]=inf;
        vis[i][j][k][l]=0;
    }
    d[sx][sy][0][0]=0;
    q.push(node(sx,sy,0,0));
    vis[sx][sy][0][0]=1;
    while(!q.empty())
    {
        node t=q.front();
        q.pop();
        if(t.x==ex&&t.y==ey&&t.c==0)
        {
            return d[ex][ey][t.d][0];
        }
        int dx=t.x+dir[t.d][0],dy=t.y+dir[t.d][1];
        int dd=t.d,dc=(t.c+1)%5;
        if(dx>=0&&dx<n&&dy>=0&&dy<m&&!vis[dx][dy][dd][dc]&&g[dx][dy]!='#')  //dc写成了dx找了半小时=_=||
        {
            d[dx][dy][dd][dc]=d[t.x][t.y][t.d][t.c]+1;
            vis[dx][dy][dd][dc]=1;
            q.push(node(dx,dy,dd,dc));
        }
        dx=t.x,dy=t.y;
        dd=(t.d+1)%4,dc=t.c;
        if(!vis[dx][dy][dd][dc])
        {
            d[dx][dy][dd][dc]=d[t.x][t.y][t.d][t.c]+1;
            vis[dx][dy][dd][dc]=1;
            q.push(node(dx,dy,dd,dc));
        }
        dx=t.x,dy=t.y;
        dd=(t.d-1+4)%4,dc=t.c;
         if(!vis[dx][dy][dd][dc])
        {
            d[dx][dy][dd][dc]=d[t.x][t.y][t.d][t.c]+1;
            vis[dx][dy][dd][dc]=1;
            q.push(node(dx,dy,dd,dc));
        }
    }
    return inf;
}
int main()
{
    int kase=0;
    while(scanf("%d%d",&n,&m)&&(n||m))
    {
        for(int i=0;i<n;i++)
        {
            scanf("%s",g[i]);
            for(int j=0;j<m;j++){
                if(g[i][j]=='S') {sx=i;sy=j;}
                if(g[i][j]=='T') {ex=i;ey=j;}
            }
        }
        int ans=bfs();
        if(kase) puts("");
        printf("Case #%d
",++kase);
        if(ans!=inf) printf("minimum time = %d sec
",ans);
        else puts("destination not reachable");
    }

}

The Necklace

 UVA - 10054 

无向图的欧拉回路+输出路径

#include <bits/stdc++.h>
using namespace std;
int g[55][55];
int f[55];
int deg[55];
int n;

int gf(int x)
{
  return x==f[x]?x:f[x]=gf(f[x]);
}

void dfs(int u)
{
    for(int i=1;i<=50;i++) if(g[u][i])
    {
        g[u][i]--;
        g[i][u]--;
        dfs(i);
        printf("%d %d
",i,u);
    }
}
int main()
{
    int t;
    int kase=0;
    scanf("%d",&t);
    while(t--)
    {
        for(int i=0;i<=55;i++) f[i]=i;
        memset(deg,0,sizeof(deg));
        memset(g,0,sizeof(g));
        scanf("%d",&n);
        int u,v;
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&u,&v);
            g[u][v]++;
            g[v][u]++;
            deg[u]++;
            deg[v]++;
            int pu=gf(u);
            int pv=gf(v);
            if(pu!=pv) f[pu]=pv;
        }
        if(kase) puts("");
        printf("Case #%d
",++kase);
        int rt=0;
        int flag=1;
        for(int i=1;i<=50;i++) if(deg[i])
        {
            if(deg[i]&1) {
                flag=0;
                break;
            }
            if(rt==0) rt=gf(i);
            else{
                int v=gf(i);
                if(v!=rt) {
                    flag=0;
                    break;
                }
            }
        }
        if(flag)
        {
            dfs(rt);
        }
        else puts("some beads may be lost");
    }
}

Play on Words

 UVA - 10129 

有向图欧拉路径

#include<cstdio>
#include<cstring>
#include<set>
#include<iostream>
#include<cctype>
#include<string>
#include<sstream>
#include<algorithm>
#include<map>
#define LL long long
using namespace std;
const int maxn=100010;
int in[30],out[30];
int f[30];
set<int> si;
void init()
{
    for(int i=0;i<30;i++)
    {
        in[i]=0;
        out[i]=0;
        f[i]=i;
    }
}

int gf(int x)
{
    return x==f[x]?x:f[x]=gf(f[x]);
}

void uni(int a,int b)
{
    int pa=gf(a);
    int pb=gf(b);
    f[pa]=pb;
}
string s;
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int ok=1;
        si.clear();
        init();
        int n;
        int a,b;
        int ctin=0,ctout=0,ct=0;
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        {
            cin>>s;
            a=s[0]-'a';
            b=s[s.length()-1]-'a';
            si.insert(a);
            si.insert(b);
            in[a]++;
            out[b]++;
            if(gf(a)!=gf(b)) uni(a,b);
        }
        int u=gf(a);
        for(set<int> ::iterator it=si.begin();it!=si.end();it++)
        {
            if(gf(*it)!=u) ct++;
            if(ct>0) {ok=0;break;}
            if(in[*it]-out[*it]==1) ctin++;
            else if(in[*it]-out[*it]==-1) ctout++;
            else if(in[*it]-out[*it]>1||in[*it]-out[*it]<-1) {ok=0;break;}
            if(ctin>1||ctout>1) {ok=0;break;}
        }

        if(ok) puts("Ordering is possible.");
        else puts("The door cannot be opened.");
    }
}

---

连通分量

---

Knights of the Round Table

 UVALive - 3523

无向图的点的双联通分量

二分图的判定

题目要求的是不在任何一个奇圈上的人有几个

先求出所有的点双联通分量，如果该分量不是二分图说明有奇圈，有奇圈就说明每个人都可以参加至少一场会议（p317有证明，不难），把这些人标记，最后拿总人数减去这些人就是答案了。

#include <bits/stdc++.h>
using namespace std;
const int maxv=1010;
const int maxe=1000010;

int n,m;

int g[maxv][maxv];
struct Edge
{
    int u,v,nex;
}e[maxe<<1];
int head[maxv];
int cnt=0;
void add(int u,int v)
{
    e[cnt].u=u;
    e[cnt].v=v;
    e[cnt].nex=head[u];
    head[u]=cnt++;
}
void init()
{
    memset(g,0,sizeof(g));
    memset(head,-1,sizeof(head));
    cnt=0;
}

int pre[maxv],iscut[maxv],bccno[maxv],dfsk,bcc_cnt;
vector<int> bcc[maxv];
stack<int> s;

int dfs(int u,int f)
{
    int lowu=pre[u]=++dfsk;
    int child=0;
    for(int i=head[u];i!=-1;i=e[i].nex)
    {
        int v=e[i].v;
        if(!pre[v])
        {
            s.push(i);
            child++;
            int lowv=dfs(v,u);
            lowu=min(lowu,lowv);
            if(lowv>=pre[u])
            {
                iscut[u]=1;
                bcc_cnt++;
                bcc[bcc_cnt].clear(); //bcc从1开始编号
                for(;;)
                {
                    int te=s.top();
                    s.pop();
                    Edge p=e[te];
                    if(bccno[p.u]!=bcc_cnt) {bcc[bcc_cnt].push_back(p.u);bccno[p.u]=bcc_cnt; }
                    if(bccno[p.v]!=bcc_cnt) {bcc[bcc_cnt].push_back(p.v);bccno[p.v]=bcc_cnt; }
                    if(p.u==u&&p.v==v) break;
                }
            }
        }
        else if(pre[v]<pre[u]&&v!=f)
        {
            s.push(i);
            lowu=min(lowu,pre[v]);
        }
    }
    if(f<0&&child==1) iscut[u]=0;
    return lowu;
}

void find_bcc(int n)
{
    memset(pre,0,sizeof(pre));
    memset(iscut,0,sizeof(iscut));
    memset(bccno,0,sizeof(bccno));
    dfsk=bcc_cnt=0;
    for(int i=0;i<n;i++) if(!pre[i])
        dfs(i,-1);
}

int odd[maxv];  //是否可以参加会议
int color[maxv];
bool bipartite(int u,int b)
{
    for(int i=head[u];i!=-1;i=e[i].nex)
    {
        int v=e[i].v;
        if(bccno[v]!=b) continue;
        if(color[u]==color[v]) return false;
        if(!color[v])
        {
            color[v]=3-color[u];
            if(!bipartite(v,b)) return false;
        }
    }
    return true;
}
int main()
{
    

    while(scanf("%d%d",&n,&m)!=EOF&&(n||m))
    {
        init();
        int u,v;
        for(int i=0;i<m;i++){
            scanf("%d%d",&u,&v);
            u--;v--;
            g[u][v]=g[v][u]=1;
        }
        for(int i=0;i<n;i++)
            for(int j=i+1;j<n;j++) if(!g[i][j])
            {
                add(i,j);
                add(j,i);
            }
        find_bcc(n);

        memset(odd,0,sizeof(odd));
        for(int i=1;i<=bcc_cnt;i++)
        {
            memset(color,0,sizeof(color));
            for(int j=0;j<bcc[i].size();j++) bccno[bcc[i][j]]=i;
            int u=bcc[i][0];
            color[u]=1;
            if(!bipartite(u,i))
                for(int j=0;j<bcc[i].size();j++) odd[bcc[i][j]]=1;
        }
        int ans=n;
        for(int i=0;i<n;i++) if(odd[i]) ans--;
        printf("%d
",ans);
    }
    return 0;
}

 下面这份代码有问题，，注释里写了

#include <iostream>
#include <cstring>
#include <stack>
#include <vector>
#include <cstdio>
using namespace std;
const int maxv=1010;
int A[maxv][maxv];
int n,m;
struct Edge
{
    int u,v,nex;
}e[maxv*maxv<<1];
int head[maxv];
int cnt=0;
void init()
{
    memset(head,-1,sizeof(head));
    cnt=0;
}
void add(int u,int v)
{
    e[cnt].u=u;
    e[cnt].v=v;
    e[cnt].nex=head[u];
    head[u]=cnt++;
}

int pre[maxv],iscut[maxv],bccno[maxv],dfsk,bcc_cnt;
stack<int> s;
vector<int> bcc[maxv];

int dfs(int u,int id)
{
    int lowu=pre[u]=++dfsk;
    int child=0;
    for(int i=head[u];i!=-1;i=e[i].nex)
    {
        int v=e[i].v;
        if(i==(id^1)) continue;
        if(!pre[v])
        {
            child++;
            s.push(i);
            int lowv=dfs(v,id);
            lowu=min(lowv,lowu);
            if(lowv>=pre[u])  // 说明u是割顶
            {
                iscut[u]=1;
                bcc_cnt++;
                bcc[bcc_cnt].clear();
                for(;;)
                {
                    Edge p=e[s.top()];
                    s.pop();
                    if(bccno[p.u]!=bcc_cnt) {bcc[bcc_cnt].push_back(p.u);bccno[p.u]=bcc_cnt;}
                    if(bccno[p.v]!=bcc_cnt) {bcc[bcc_cnt].push_back(p.v);bccno[p.v]=bcc_cnt;}
                    if(p.v==v&&p.u==u) break;
                }
            }
        }
        else   if(pre[v]<pre[u])   //不加这一句就会错，，无解。。pre[v]难道不是一定小于pre[u]吗？？
        {
            s.push(i);
            lowu=min(lowu,pre[v]);
        }
    }
    if(id<0&&child==1) iscut[u]=0;
    return lowu;
}

void find_bcc(int n)
{
    memset(pre,0,sizeof(pre));
    memset(bccno,0,sizeof(bccno));
    memset(iscut,0,sizeof(iscut));
    dfsk=bcc_cnt=0;
    for(int i=0;i<n;i++) if(!pre[i]) dfs(i,-1);
}
int odd[maxv],color[maxv];
int bigraph(int u,int b)
{
    for(int i=head[u];i!=-1;i=e[i].nex)
    {
        int v=e[i].v;
        if(bccno[v]!=b) continue;
        if(color[v]==color[u]) return 0;
        if(!color[v])
        {
            color[v]=3-color[u];
            if(!bigraph(v,b)) return 0;
        }
    }
    return 1;
}
int main()
{
    while(scanf("%d%d",&n,&m)&&(n||m))
    {
        init();
        int u,v;
        memset(A,0,sizeof(A));
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&u,&v);
            u--;v--;
            A[u][v]=A[v][u]=1;
        }
        for(int i=0;i<n;i++)
            for(int j=i+1;j<n;j++) if(!A[i][j])
            {
                add(i,j);
                add(j,i);
            }

        find_bcc(n);

        memset(odd,0,sizeof(odd));
        for(int i=1;i<=bcc_cnt;i++)
        {
            memset(color,0,sizeof(color));
            for(int j=0;j<bcc[i].size();j++) bccno[bcc[i][j]]=i;  //有可能某个点属于多个环
            int u=bcc[i][0];
            color[u]=1;
            if(!bigraph(u,i))  //不是二分图----有奇环----都可参加至少一次会议
                for(int j=0;j<bcc[i].size();j++) odd[bcc[i][j]]=1;
        }
        int ans=n;
        for(int i=0;i<n;i++)
            if(odd[i]) ans--;
        printf("%d
",ans);
    }
}

问题解决了，，pre[v]不一定小于pre[u],

在一个环里，如果顺时针dfs的话，最后会有pre[v]<pre[u],然后倒推回去会把这个环加到同一个新的联通分量里

接下来，按dfs接着走，会逆时针再去访问这个环，这时候会有pre[v]>pre[u],这种情况其实已经不能再把那条边压到栈里了，因为这个环已经记录过了，不用再处理

---

Mining Your Own Business

 UVALive - 5135 

无向图求割顶，，建图时总是忘记初始化。。。

#include <bits/stdc++.h>
using namespace std;
#define LL long long
const int maxv=1010;
const int maxe=100010;

int n,m;
struct Edge
{
    int u,v,nex;
}e[maxe];
int head[maxe]; //
int cnt=0;
void init()
{
    memset(head,-1,sizeof(head));
    cnt=0;
}
void add(int u,int v)
{
    e[cnt].u=u;
    e[cnt].v=v;
    e[cnt].nex=head[u];
    head[u]=cnt++;
}

int pre[maxe],bccno[maxe],iscut[maxe],dfsk,bcc_cnt;
vector<int> bcc[maxe]; //边双联通分量
stack<int> s;  //边号
int dfs(int u,int f)
{
    int lowu=pre[u]=++dfsk;
    int child=0;
    for(int i=head[u];i!=-1;i=e[i].nex)
    {
        int v=e[i].v;
        if(!pre[v])
        {
            s.push(i);
            child++;
            int lowv=dfs(v,u);
            lowu=min(lowu,lowv);
            if(lowv>=pre[u])
            {
                iscut[u]=1;
                bcc_cnt++;
                bcc[bcc_cnt].clear();
                for(;;)
                {
                    int te=s.top();
                    s.pop();
                    Edge p=e[te];
                    if(bccno[p.u]!=bcc_cnt) {bcc[bcc_cnt].push_back(p.u); bccno[p.u]=bcc_cnt;}
                    if(bccno[p.v]!=bcc_cnt) {bcc[bcc_cnt].push_back(p.v); bccno[p.v]=bcc_cnt;}
                    if(p.u==u&&p.v==v) break;
                }
            }
        }
        else if(pre[v]<pre[u]&&v!=f)
        {
            s.push(i);
            lowu=min(pre[v],lowu);
        }
    }
    if(f<0&&child==1) iscut[u]=0;
    return lowu;
}

void find_bcc(int n)
{
    memset(pre,0,sizeof(pre));
    memset(bccno,0,sizeof(bccno));
    memset(iscut,0,sizeof(iscut));
    dfsk=bcc_cnt=0;
    for(int i=0;i<n;i++) if(!pre[i])
        dfs(i,-1);
}

int main()
{
    int kase=0;
   // freopen("in.txt","r",stdin);
    while(scanf("%d",&m)&&m)
    {
        n=0;
        init();
        int u,v;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&u,&v);
            u--;v--;
            add(u,v);
            add(v,u);
            n=max(n,max(u,v));
        }
        find_bcc(n);
        LL ans1=0,ans2=1;
        for(int i=1;i<=bcc_cnt;i++)
        {
            int cut_cnt=0;
            for(int j=0;j<bcc[i].size();j++)
                if(iscut[bcc[i][j]]) cut_cnt++; //统计bcc中割顶数目
            if(cut_cnt==1)
            {
                ans1++;
                ans2*=(long long)(bcc[i].size()-1);
            }
        }
        if(bcc_cnt==1)
        {
            ans1=2;
            ans2=bcc[1].size()*(bcc[1].size()-1)/2;
        }
        printf("Case %d: %lld %lld
",++kase,ans1,ans2);
    }
}

Proving Equivalences

 UVALive - 4287 

有向图，求双联通分量，然后再把每个联通分量缩成一个点

当每个点都有入有出时才成为双联通（不知道怎么描述，等想清楚了再回来写）

ans=max(a,b);

#include <bits/stdc++.h>
using namespace std;
const int maxv=20010;
const int maxe=50010;

int n,m;

struct Edge
{
    int u,v,nex;
}e[maxe<<1];
int head[maxv];
int cnt=0;
void init()
{
    memset(head,-1,sizeof(head));
    cnt=0;
}
void add(int u,int v)
{
    e[cnt].u=u;
    e[cnt].v=v;
    e[cnt].nex=head[u];
    head[u]=cnt++;
}

int pre[maxv],sccno[maxv],lowlink[maxv],dfsk,scc_cnt;
stack<int> s;

void dfs(int u)
{
    pre[u]=lowlink[u]=++dfsk;
    s.push(u);
    for(int i=head[u];i!=-1;i=e[i].nex)
    {
        int v=e[i].v;
        if(!pre[v])
        {
            dfs(v);
            lowlink[u]=min(lowlink[u],lowlink[v]);
        }
        else if(!sccno[v])
            lowlink[u]=min(lowlink[u],lowlink[v]);
    }
    if(lowlink[u]==pre[u])
    {
        scc_cnt++;
        for(;;)
        {
            int x=s.top();
            s.pop();
            sccno[x]=scc_cnt;
            if(x==u) break;
        }
    }
}

void find_scc(int n)
{
    dfsk=scc_cnt=0;
    memset(sccno,0,sizeof(sccno));
    memset(pre,0,sizeof(pre));
    for(int i=0;i<n;i++) if(!pre[i])
        dfs(i);
}
int in0[maxv],out0[maxv];

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        init();
        scanf("%d%d",&n,&m);
        for(int i=0;i<m;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            u--;v--;
            add(u,v);
        }

        find_scc(n);

        for(int i=1;i<=scc_cnt;i++) in0[i]=out0[i]=1;
        for(int u=0;u<n;u++)
            for(int i=head[u];i!=-1;i=e[i].nex)
        {
            int v=e[i].v;
            if(sccno[v]!=sccno[u]) in0[sccno[v]]=out0[sccno[u]]=0;
        }
        int a=0,b=0;
        for(int i=1;i<=scc_cnt;i++)
        {
            if(in0[i]) a++;
            if(out0[i]) b++;
        }
        int ans=max(a,b);
        if(scc_cnt==1) ans=0;
        printf("%d
",ans);
    }
    return 0;
}

The Largest Clique

 UVA - 11324 

先求出SCC，然后缩点，就变成了一个DAG，每个点的权值为内点的个数，用DP求解最大值。

#include <bits/stdc++.h>
using namespace std;
const int maxv=1010;

int n,m;

vector<int> G[maxv];
int pre[maxv],lowlink[maxv],sccno[maxv],dfsk,scc_cnt;
stack<int> s;

void dfs(int u)
{
    pre[u]=lowlink[u]=++dfsk;
    s.push(u);
    for(int i=0;i<G[u].size();i++)
    {
        int v=G[u][i];
        if(!pre[v])
        {
            dfs(v);
            lowlink[u]=min(lowlink[u],lowlink[v]);
        }
        else if(!sccno[v]) lowlink[u]=min(lowlink[u],lowlink[v]);
    }
    if(lowlink[u]==pre[u])
    {
        scc_cnt++;
        for(;;)
        {
            int x=s.top();
            s.pop();
            sccno[x]=scc_cnt;
            if(x==u) break;
        }
    }
}
void find_scc(int n)
{
    memset(pre,0,sizeof(pre));
    memset(lowlink,0,sizeof(lowlink));
    memset(sccno,0,sizeof(sccno));
    dfsk=scc_cnt=0;
    for(int i=0;i<n;i++) if(!pre[i])
        dfs(i);
}

int sz[maxv],d[maxv],TG[maxv][maxv];  //DP
int dp(int u)
{
    if(d[u]>0) return d[u];
    d[u]=sz[u];
    for(int i=1;i<=scc_cnt;i++)
        if(TG[u][i]&&u!=i) d[u]=max(d[u],dp(i)+sz[u]);
    return d[u];
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        for(int i=0;i<n;i++) G[i].clear();
        int u,v;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&u,&v);
            u--;v--;
            G[u].push_back(v);
        }
        find_scc(n);

        //DP
        memset(d,-1,sizeof(d));
        memset(sz,0,sizeof(sz));
        memset(TG,0,sizeof(TG));
        for(int i=0;i<n;i++)
        {
            sz[sccno[i]]++;
            for(int j=0;j<G[i].size();j++)
            TG[sccno[i]][sccno[G[i][j]]]=1;
        }
        int ans=0;
        for(int i=1;i<=scc_cnt;i++)
            ans=max(ans,dp(i));
        printf("%d
",ans);
    }
}

Now or later

 UVALive - 3211 

 2sat

第一次接触是大一刚开学不久的离散课上老师提到的，神奇orz

下面是lrj书上的模板

 ▄█▀█●

#include <bits/stdc++.h>
using namespace std;
const int maxn=2010;
struct TwoSAT
{
    int n;
    vector<int> G[maxn<<1];
    bool mark[maxn<<1];
    int s[maxn<<1],c;

    bool dfs(int x)
    {
        if(mark[x^1]) return false;
        if(mark[x]) return true;
        mark[x]=true;
        s[c++]=x;
        for(int i=0;i<G[x].size();i++)
            if(!dfs(G[x][i])) return false;
        return true;
    }

    void init(int n)
    {
        this->n=n;
        for(int i=0;i<n*2;i++) G[i].clear();
        memset(mark,0,sizeof(mark));
    }

    void add_clause(int x,int xv,int y,int yv)
    {
        x=x*2+xv;
        y=y*2+yv;
        G[x^1].push_back(y);
        G[y^1].push_back(x);
    }

    bool solve()
    {
        for(int i=0;i<n*2;i+=2)
            if(!mark[i]&&!mark[i^1])
            {
                c=0;
                if(!dfs(i))
                {
                    while(c>0) mark[s[--c]]=false;
                    if(!dfs(i+1)) return false;
                }
            }
        return true;
    }
}solver;
int n;
int T[maxn][2];

bool test(int diff)
{
    solver.init(n);
    for(int i=0;i<n;i++) for(int a=0;a<2;a++)
        for(int j=i+1;j<n;j++) for(int b=0;b<2;b++)
        if(abs(T[i][a]-T[j][b])<diff) solver.add_clause(i,a^1,j,b^1);
    return solver.solve();
}

int main()
{
    while(scanf("%d",&n)==1&&n)
    {
        int L=0,R=0;
        for(int i=0;i<n;i++) for(int a=0;a<2;a++)
        {
            scanf("%d",&T[i][a]);
            R=max(R,T[i][a]);
        }
        while(L<R)
        {
            int M=(R-L+1)/2+L;
            if(test(M)) L=M;
            else R=M-1;
        }
        printf("%d
",L);
    }
    return 0;


}

Astronauts

 UVALive - 3713 

 还是2sat，，模板好用啊 ▄█▀█●

#include <bits/stdc++.h>
using namespace std;
const int maxn=100010;
struct TwoSAT
{
    int n;
    vector<int> G[maxn<<1];
    bool mark[maxn<<1];
    int s[maxn<<1],c;

    bool dfs(int x)
    {
        if(mark[x^1]) return false;
        if(mark[x]) return true;
        mark[x]=true;
        s[c++]=x;
        for(int i=0;i<G[x].size();i++)
            if(!dfs(G[x][i])) return false;
        return true;
    }

    void init(int n)
    {
        this->n=n;
        for(int i=0;i<n*2;i++) G[i].clear();
        memset(mark,0,sizeof(mark));
    }

    void add_clause(int x,int xv,int y,int yv)
    {
        x=x*2+xv;
        y=y*2+yv;
        G[x^1].push_back(y);
        G[y^1].push_back(x);
    }

    bool solve()
    {
        for(int i=0;i<n*2;i+=2)
            if(!mark[i]&&!mark[i^1])
            {
                c=0;
                if(!dfs(i))
                {
                    while(c>0) mark[s[--c]]=false;
                    if(!dfs(i+1)) return false;
                }
            }
        return true;
    }
}solver;
int n,m;
int age[maxn],sum;

bool check(int x)
{
    return age[x]*n<sum;
}

int main()
{
    while(scanf("%d%d",&n,&m)!=EOF&&(n||m))
    {
        sum=0;
        for(int i=0;i<n;i++) {
            scanf("%d",&age[i]);
            sum+=age[i];
        }
        solver.init(n);
        for(int i=0;i<m;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            a--;b--;
            solver.add_clause(a,1,b,1);
            if(check(a)==check(b)) solver.add_clause(a,0,b,0);
        }
        if(!solver.solve()) printf("No solution
");
        else {
            for(int i=0;i<n;i++)
            if(solver.mark[i*2]) printf("C
");
            else if(check(i)) puts("B");
            else puts("A");
        }
    }
    return 0;


}

---

最短路：

---

Airport Express

 UVA - 11374

怎么说呢，，看了一个人的代码，里面有一点小错误，搞了很久才发现，这种人太不负责任了，贴代码也要有原则的吧=_=||

算是对输出路径有了更深的理解

#include <bits/stdc++.h>
using namespace std;
const int inf=0x3f3f3f3f;
const int maxv=1010;
const int maxe=1010;

struct Edge
{
    int u,v,w;
    int nex;
}e[maxe<<1];
int head[maxv];
int cnt=0;
void init()
{
    memset(head,-1,sizeof(head));
    cnt=0;
}
void add(int u,int v,int w)
{
    e[cnt].u=u;
    e[cnt].v=v;
    e[cnt].w=w;
    e[cnt].nex=head[u];
    head[u]=cnt++;
}

typedef pair<int,int> PII;
int dis[maxv];
int par[maxv];
void dijkstra(int s)
{
    priority_queue<PII,vector<PII>,greater<PII> > pq;
    for(int i=0;i<maxv;i++) dis[i]=inf;
    dis[s]=0;
    pq.push(PII(0,s));
    while(!pq.empty())
    {
        PII temp=pq.top();
        pq.pop();
        int u=temp.second;
        if(dis[u]<temp.first) continue;
        for(int i=head[u];i!=-1;i=e[i].nex)
        {
            if(dis[e[i].v]>dis[u]+e[i].w)
            {
                dis[e[i].v]=dis[u]+e[i].w;
                par[e[i].v]=i;
                pq.push(PII(dis[e[i].v],e[i].v));
            }
        }
    }
}
int n,ss,ee;
int ds[maxv],de[maxv];
int p[maxv],p1[maxv];

void print(int a)
{
    if(a==ss)
    {
        printf("%d",a+1);
    }
    else
    {
        int x=p1[a];
        print(e[x].u);
        printf(" %d",a+1);
    }
    return ;
}

int main()
{
    int kase=0;

    while(scanf("%d%d%d",&n,&ss,&ee)!=EOF&&n)
    {
        if(kase++) puts("");
        ss--;ee--;
        init();
        int u,v,w;
        int m;
        scanf("%d",&m);
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            u--,v--;
            add(u,v,w);
            add(v,u,w);
        }
        dijkstra(ss);
        for(int i=0;i<n;i++) {ds[i]=dis[i];p1[i]=par[i];}
        pa[ss]=-1;
        dijkstra(ee);
        for(int i=0;i<n;i++) {de[i]=dis[i];p[i]=par[i];}
        p[ee]=-1;


        int ans1=ds[ee];
        int a=-1,b=-1;
        int k;
        scanf("%d",&k);
        for(int i=0;i<k;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            u--;v--;
            if(ans1>ds[u]+w+de[v])
            {
                ans1=ds[u]+w+de[v];
                a=u,b=v;
            }
            if(ans1>ds[v]+w+de[u])
            {
                ans1=ds[v]+w+de[u];
                a=v,b=u;
            }
        }

        int flag=0;
        if(a==-1)
        {
            int x=ss;
            while(x!=ee)
            {
                if(!flag){printf("%d",x+1);flag=1;}
                else printf(" %d",x+1);
                x=e[p[x]].u;
            }
            printf(" %d
",ee+1);
            printf("Ticket Not Used
%d
",ans1);
        }
        else
        {
            print(a);
            int x=b;
            while(x!=ee)
            {
                printf(" %d",x+1);
                x=e[p[x]].u;
            }
            printf(" %d
",ee+1);
            printf("%d
%d
",a+1,ans1);
        }
    }
    return 0;
}

Walk Through the Forest

 UVA - 10917

最短路树，DP求解

#include <bits/stdc++.h>
using namespace std;
const int inf=0x3f3f3f3f;
const int maxv=1010;
const int maxe=1000010; //??
int n,m;
struct Edge
{
    int u,v,w;
    int nex;
}e[maxe<<1];
int head[maxv];
int cnt=0;
void init()
{
    memset(head,-1,sizeof(head));
    cnt=0;
}
void add(int u,int v,int w)
{
    e[cnt].u=u;
    e[cnt].v=v;
    e[cnt].w=w;
    e[cnt].nex=head[u];
    head[u]=cnt++;
}
typedef pair<int,int> PII;
int dis[maxv],par[maxv];
void dijkstra(int s)
{
    priority_queue<PII,vector<PII>,greater<PII> > pq;
    for(int i=0;i<maxv;i++) dis[i]=inf;
    dis[s]=0;
    pq.push(PII(0,s));
    while(!pq.empty())
    {
        PII temp=pq.top();
        pq.pop();
        int u=temp.second;
        if(dis[u]<temp.first) continue;
        for(int i=head[u];i!=-1;i=e[i].nex)
        {
            int v=e[i].v;
            if(dis[v]>dis[u]+e[i].w)
            {
                dis[v]=dis[u]+e[i].w;
                par[v]=i;
                pq.push(PII(dis[v],v));
            }
        }
    }
}
int dp[maxv];
int DP(int u)
{
    if(u==1) return 1;
    if(dp[u]!=-1) return dp[u];
    dp[u]=0;
    for(int i=head[u];i!=-1;i=e[i].nex)
    {
        int v=e[i].v;
        if(dis[v]<dis[u]) dp[u]+=DP(v);
    }
    return dp[u];
}
int main()
{
    while(scanf("%d",&n)&&n)
    {
        scanf("%d",&m);
        init();
        int u,v,w;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            u--;v--;
            add(u,v,w);
            add(v,u,w);
        }
        dijkstra(1);
        memset(dp,-1,sizeof(dp));
        int ans=DP(0);
        printf("%d
",ans);
    }

}

Warfare And Logistics

 UVALive - 4080 

怎么今天总是踩到各种坑里=_=||

没有原题，，lrj书上说1000条边，可是我开到1000各种WA了n次

别人也是1000就过了orz。。我得开到2000才能过

无解，，看不出来代码哪里有问题

【如果每次删除一条边，要跑m次dijkstra，其实其中很多次都对最短路没有影响，因为删掉的边不在最短路里】

【因此，可以每次删除最短路树中的一条边，需要跑n次，复杂度降低到可接受程度】

---

 再补充一点补码的知识，上学期学过可是已经忘了，刚刚翻得书=_=||

正数的补码简单，直接写成二进制形式即可

对于负数，先写出对应的正数的补码，然后右边起到第一位不是0的这些位不变，其它位取反，即是负数的补码

比如  -3的补码为  0000 0011——》1111 1101

　　所以-3取反之后就变成了0000 0010，即2

在用前向星存边时，从0开始，那么i与i^1是一对边，i是正向，i^1是反向

如果要求某条边i的正向边怎么求呢？只需要（i&（-2））即得到正向边

因为-2的补码为11111110，（i&（-2））即把最右那位置0，其它位不变，得到的就是正向边了

#include <bits/stdc++.h>
#define LL long long
using namespace std;
const int inf=0x3f3f3f3f;
const int maxv=110;
const int maxe=2010;
int n,m,L;
struct Edge
{
    int u,v,w;
    int nex;
}e[maxe<<1];
int head[maxv];
int cnt=0;
void init()
{
    memset(head,-1,sizeof(head));
    cnt=0;
}
void add(int u,int v,int w)
{
    e[cnt].u=u;
    e[cnt].v=v;
    e[cnt].w=w;
    e[cnt].nex=head[u];
    head[u]=cnt++;
}

typedef pair<int,int> PII;
int dis[maxv],par[maxv];
void dijkstra(int s,bool c,int e1)
{
    priority_queue<PII,vector<PII>,greater<PII> > pq;
    for(int i=0;i<maxv;i++) dis[i]=L;
    dis[s]=0;
    pq.push(PII(0,s));
    par[s]=-1;
    while(!pq.empty())
    {
        PII t=pq.top();
        pq.pop();
        int u=t.second;
        if(dis[u]<t.first) continue;
        for(int i=head[u];i!=-1;i=e[i].nex)
        {
            if(i==e1||i==(e1^1)) continue;   //
            int v=e[i].v;
            if(dis[v]>dis[u]+e[i].w)
            {
                dis[v]=dis[u]+e[i].w;
                if(c) par[v]=i;
                pq.push(PII(dis[v],v));
            }
        }
    }
}
LL cal()
{
    LL temp=0;
    for(int i=0;i<n;i++)
        temp+=dis[i];
    return temp;
}
vector<int> vv;
int delta[maxe];

int main()
{
    while(scanf("%d%d%d",&n,&m,&L)!=EOF)
    {
        init();
        int u,v,w;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            u--;v--;
            add(u,v,w);
            add(v,u,w);
        }
        LL ans=0;
        vv.clear();
        memset(delta,0,sizeof(delta));
        for(int i=0;i<n;i++)
        {
            dijkstra(i,1,-1);
            LL temp=cal();
            ans+=temp;
            for(int j=0;j<n;j++)
                if(par[j]!=-1)
            {
                dijkstra(i,0,par[j]);
                int id=par[j]&(~1);   //
                if(!delta[id]) vv.push_back(id);
                delta[id]+=cal()-temp;
            }

        }
        int maxdelta=0;
        for(int i=0;i<(int)vv.size();i++)
            maxdelta=max(maxdelta,delta[vv[i]]);
        printf("%lld %lld
",ans,ans+maxdelta);
    }
}

 附上大佬代码

#include<bits/stdc++.h>
using namespace std;

const int maxn = 102, maxm = 2002;
int head[maxn], to[maxm], nxt[maxm],wei[maxm],ecnt;
int delta[maxm];

void addEdge(int u,int v,int w)
{
    to[ecnt] = v;
    nxt[ecnt] = head[u];
    wei[ecnt] = w;
    head[u] = ecnt++;
}

typedef pair<int,int> Node;
#define fi first
#define se second

int d[maxn],pa[maxn];
typedef long long ll;

void dijkstra(int n,int s,int L,bool flag,int e1,int e2)// e1 e2 边应该忽略
{
    priority_queue<Node,vector<Node>,greater<Node> > q;
    fill(d,d+n,L);
    d[s] = 0; q.push(Node(0,s)); pa[s] = -1;
    while(q.size()){
        Node x = q.top(); q.pop();
        int u = x.se;
        if(x.fi != d[u]) continue;
        for(int i = head[u]; ~i; i = nxt[i])if(i!=e1 && i!=e2) {
            int v = to[i];
            if(d[v] > d[u]+wei[i]){
                d[v] = d[u]+wei[i];
                if(flag) pa[v] = i; // 入边编号
                q.push(Node(d[v],v));
            }
        }
    }
}

ll cal(int n)
{
    ll ret = 0;
    for(int i = 0; i < n; i++){
        ret += d[i];
    }
    return ret;
}


void init()
{
    memset(head,-1,sizeof(head));
    ecnt = 0;
    memset(delta,0,sizeof(delta));
}

int main()
{
    //freopen("in.txt","r",stdin);
    int n,m,L;
    while(~scanf("%d%d%d",&n,&m,&L)){
        init();
         while(m--){
            int u,v,w; scanf("%d%d%d",&u,&v,&w);
            addEdge(--u,--v,w); addEdge(v,u,w);
        }
        ll ans1 = 0;
        vector<int> edges;
        for(int u = 0; u < n; u++){
            dijkstra(n,u,L,true,-1,-1);
            ll t  = cal(n);
            ans1 += t;
            for(int i = 0; i < n; i++){
                if(~pa[i]){
                    dijkstra(n,u,L,false,pa[i],pa[i]^1);
                    int eid = pa[i]&(~1);
                    if(!delta[eid]) edges.push_back(eid);
                    delta[eid] += cal(n)-t;
                }
            }
        }
        int MaxDelta = 0;
        for(int i = 0; i < (int)edges.size(); i++){
            MaxDelta = max(MaxDelta,delta[edges[i]]);
        }
        printf("%lld %lld
",ans1,ans1+MaxDelta);
    }
    return 0;
}

The Toll! Revisited

 UVA - 10537

不想做了，，先贴上LRJ代码，日后再做

// UVa10537 Toll! Revisited
// Rujia Liu
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int maxn = 52 + 10;
const long long INF = 1LL << 60;
typedef long long LL;

int n, G[maxn][maxn], src, dest, p;
int mark[maxn]; // 标记
LL d[maxn];     // d[i]表示从点i出发（已经交过点i的税了）时至少要带多少东西，到dest时还能剩p个东西

int read_node() {
  char ch[9];
  scanf("%s", ch);
  if(ch[0] >= 'A' && ch[0] <= 'Z') return ch[0] - 'A';
  else return ch[0] - 'a' + 26;
}

char format_node(int u) {
  return u < 26 ? 'A' + u : 'a' + (u - 26);
}

// 拿着item个东西去结点next，还剩多少个东西
LL forward(LL item, int next) {
  if(next < 26) return item - (item + 19) / 20;
  return item - 1;
}

// 至少要拿着多少个东西到达结点u，交税以后还能剩d[u]个东西
// 为了使代码容易理解，这里使用一种不太数学的解法
LL back(int u) {
  if(u >= 26) return d[u]+1;
  LL X = d[u] * 20 / 19; // 初始值
  while(forward(X, u) < d[u]) X++; // 调整
  return X;
}

void solve() {
  n = 52; // 总是有52个结点
  memset(mark, 0, sizeof(mark));
  d[dest] = p;
  mark[dest] = 1;
  for(int i = 0; i < n; i++) if(i != dest) {
    d[i] = INF;
    if(G[i][dest]) d[i] = back(dest);
  }

  // Dijkstra主过程，逆推
  while(!mark[src]) {
    // 找最小的d
    int minu = -1;
    for(int i = 0; i < n; i++) if(!mark[i]) {
      if(minu < 0 || d[i] < d[minu]) minu = i;
    }
    mark[minu] = 1;
    // 更新其他结点的d
    for(int i = 0; i < n; i++) if(!mark[i]) {
      if(G[i][minu]) d[i] = min(d[i], back(minu));
    }
  }

  // 输出
  printf("%lld
", d[src]);
  printf("%c", format_node(src));
  int u = src;
  LL item = d[src];
  while(u != dest) {
    int next;
    for(next = 0; next < n; next++) // 找到第一个可以走的结点
      if(G[u][next] && forward(item, next) >= d[next]) break;
    item = d[next];
    printf("-%c", format_node(next));
    u = next;
  }
  printf("
");
}

int main() {
  int kase = 0;
  while(scanf("%d", &n) == 1 && n >= 0) {
    memset(G, 0, sizeof(G));
    for(int i = 0; i < n; i++) {
      int u = read_node();
      int v = read_node();
      if(u != v) G[u][v] = G[v][u] = 1;
    }
    scanf("%d", &p);
    src = read_node();
    dest = read_node();
    printf("Case %d:
", ++kase);
    solve();
  }
  return 0;
}

Halum

 UVA - 11478 

差分约束

简直要崩溃了，，无法理解。。。。。。

---

事实证明是书上写错了，不是非负，而是要求必须大于0.

忧伤=_=||

// UVa11478 Halum
// Rujia Liu
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;

const int INF = 1000000000;
const int maxn = 500 + 10;
const int maxm = 2700 + 10;

struct Edge {
  int to, dist;
};

// 邻接表写法
struct BellmanFord {
  int n, m;
  Edge edges[maxm];
  int head[maxn];
  int next[maxm];
  bool inq[maxn];   // 是否在队列中
  int d[maxn];      // s到各个点的距离
  int cnt[maxn];    // 进队次数

  void init(int n) {
    this->n = n;
    m = 0;
    memset(head, -1, sizeof(head));
  }

  void AddEdge(int from, int to, int dist) {
    next[m] = head[from];
    head[from] = m;
    edges[m++] = (Edge){to, dist};
  }

  bool negativeCycle() {
    queue<int> Q;
    memset(inq, 0, sizeof(inq));
    memset(cnt, 0, sizeof(cnt));
    for(int i = 0; i < n; i++) { d[i] = 0; Q.push(i); }

    int u;
    while(!Q.empty()) {
      u = Q.front(); Q.pop();
      inq[u] = false;
      for(int i = head[u]; i != -1; i = next[i]) {
        Edge& e = edges[i];
        if(d[e.to] > d[u] + e.dist) {
          d[e.to] = d[u] + e.dist;
          if(!inq[e.to]) { Q.push(e.to); inq[e.to] = true; if(++cnt[e.to] > n) return true; }
        }
      }
    }
    return false;
  }
};

BellmanFord solver;

// 判断在初始差分约束系统的每个不等式右侧同时减去x之后是否有解
bool test(int x) {
  for(int i = 0; i < solver.m; i++)
    solver.edges[i].dist -= x;
  bool ret = solver.negativeCycle();
  for(int i = 0; i < solver.m; i++)
    solver.edges[i].dist += x;
  return !ret; // 如果有负环，说明差分约束系统无解
}

int main() {
  int n, m;
  while(scanf("%d%d", &n, &m) == 2) {
    solver.init(n);
    int ub = 0;
    while(m--) {
      int u, v, d;
      scanf("%d%d%d", &u, &v, &d); ub = max(ub, d);
      solver.AddEdge(u-1, v-1, d);
    }

    if(test(ub+1)) printf("Infinite
"); // 如果可以让每条边权都>ub，说明每条边的权都增加了，重复一次会增加得更多...直到无限
    else if(!test(1)) printf("No Solution
");
    else {
      int L = 2, R = ub, ans = 1;
      while(L <= R) {
        int M = L + (R-L)/2;
        if(test(M)) { ans = M; L = M+1; } else R = M-1;
      }
      printf("%d
", ans);
    }
  }
  return 0;
}