C++博客-syhd142-文章分类-图论

UVA 10740 Not the Best

Fucker — Wed, 15 Sep 2010 06:33:00 GMT

可重复边k短路，现在一想其实很简单，就一个估界函数的设计。反向建图，用从终点到其余各点的最短距离做估界函数就好了。

#include <iostream>
#include <queue>
#include <stdio.h>
using namespace std;

#define N 1005
#define M 200005
#define INF 1 << 29

struct edge
{
    int ed, cost;
    int next;
}e[M];

struct node
{
    int id, w, f;
};

priority_queue<node> q;

bool operator < (const node a, const node b)
{
    return a.f > b.f;
}

int sp, head1[N], head2[N], d[N], rank[N];
bool mark[N];

void init(int n)
{
    sp = 0;
    for(int i = 0; i <= n; i++)
    {
        head1[i] = head2[i] = -1;
        rank[i] = 0;
    }
}

void add(int a, int b, int c)
{
    e[sp].ed = b, e[sp].cost = c;
    e[sp].next = head1[a];
    head1[a] = sp++;

    e[sp].ed = a, e[sp].cost = c;
    e[sp].next = head2[b];
    head2[b] = sp++;
}

void dijkstra(int st, int n)
{
    while(!q.empty()) q.pop();
    node u, v;
    for(int i = 0; i <= n; i++)
    {
        d[i] = INF;
        mark[i] = 0;
    }
    u.id = st, u.f = 0;
    d[st] = 0;
    q.push(u);
    while(!q.empty())
    {
        u = q.top(), q.pop();
        if(mark[u.id]) continue;
        mark[u.id] = 1;
        for(int i = head2[u.id]; i != -1; i = e[i].next)
            if(!mark[e[i].ed] && d[u.id] + e[i].cost < d[e[i].ed])
            {
                d[e[i].ed] = d[u.id] + e[i].cost;
                v.id = e[i].ed, v.f = d[e[i].ed];
                q.push(v);
            }
    }
}

int astar(int st, int ed, int n, int k)
{
    dijkstra(ed, n);
    if(d[st] == INF) return -1;
//    printf("%d\n", d[st]);
//    system("pause");
    while(!q.empty()) q.pop();
    node u, v;
    u.id = st, u.w = 0, u.f = d[st];
    q.push(u);
    while(!q.empty())
    {
        u = q.top(), q.pop();
        rank[u.id]++;
        if(rank[ed] == k) return u.w;
        if(rank[u.id] > k) continue;
        for(int i = head1[u.id]; i != -1; i = e[i].next)
        {
            v.id = e[i].ed, v.w = u.w + e[i].cost;
            v.f = v.w + d[e[i].ed];
            q.push(v);
        }
    }
    return -1;
}

int main()
{
//    freopen("in", "r", stdin);
    int n, m, a, b, c, st, ed, k, ans;
    while(scanf("%d %d", &n, &m), n + m)
    {
        init(n);
        scanf("%d %d %d", &st, &ed, &k);
        for(int i = 0; i < m; i++)
        {
            scanf("%d %d %d", &a, &b, &c);
            add(a, b, c);
        }
        if(st == ed) k++;
        ans = astar(st, ed, n, k);
        printf("%d\n", ans);
    }
    return 0;
}

Fucker 2010-09-15 14:33 发表评论

UVA 10986 Sending email

Fucker — Wed, 15 Sep 2010 03:21:00 GMT

简单图论最短路，要用到priority_queue，好久没用这个了，有点生疏。

#include <stdio.h>
#include <string.h>
#include <queue>

#define N 20005
#define M 100005
#define INF 1 << 28

struct node
{
    int id, dis;
    node (){}
    node(int id, int dis): id(id), dis(dis)
    {
    }
    bool operator < (const node &it) const
    {
        return dis > it.dis;
    }
};

struct edge
{
    int ed, cost;
    edge *next;
}*head[N], table[M];

int pos, dis[N], mk[N];

void Init(int n)
{
    pos = 0;
    memset(head, 0, sizeof(head));
}

void Add(int a, int b, int c)
{
    edge *p = &table[pos++];
    p->ed = b; p->cost = c;
    p->next = head[a];
    head[a] = p;
}

int Dijkstra(int st, int ed, int n)
{
    for(int i = 0; i < n; i++)
    {
        mk[i] = 0;
        dis[i] = INF;
    }
    dis[st] = 0;
    std::priority_queue<node> Q;
    Q.push(node(st, 0));
    node t;
    while(!Q.empty())
    {
        t = Q.top();
        Q.pop();
        if(mk[t.id]) continue;
        if(t.id == ed) return t.dis;
        mk[t.id] = 1;
        for(edge *p = head[t.id]; p; p = p->next)
        {
            if(!mk[p->ed] && p->cost + dis[t.id] < dis[p->ed])
            {
                dis[p->ed] = p->cost + dis[t.id];
                Q.push(node(p->ed, dis[p->ed]));
            }
        }
    }
    return INF;
}

int main()
{
  // freopen("in", "r", stdin);
    int cas = 1;
    int t, n, m, st, ed;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d %d %d %d", &n, &m, &st, &ed);
        Init(n);
        for(int i = 0; i < m; i++)
        {
            int a, b, c;
            scanf("%d %d %d", &a, &b, &c);
            Add(a, b, c);
            Add(b, a, c);
        }
        int ans = Dijkstra(st, ed, n);
        printf("Case #%d: ", cas++);
        if(ans == INF) puts("unreachable");
        else printf("%d\n", ans);
    }
    return 0;
}

Fucker 2010-09-15 11:21 发表评论

UVA 10801 Lift Hopping

Fucker — Tue, 14 Sep 2010 08:06:00 GMT

老了老了，这题思想有了，把这个思想变成代码花了我好长的时间阿。。唉，不久一个Dijkstra么。

#include <stdio.h>
#include <string.h>

#define N 100
#define INF 1 << 28

int g[6][N][N], lift[6][N], top[6], mk[6][N], visit[6][N], dis[6][N];

void Init()
{
    memset(mk, 0, sizeof(mk));
    for(int k = 1; k < 6; k++)
    {
        for(int i = 0; i < N; i++)
        {
            g[k][i][i] = 0;
            for(int j = i + 1; j < N; j++)
                g[k][i][j] = g[k][j][i] = INF;
            dis[k][i] = INF;
        }
    }
}

int Dijkstra(int n, int floorK)
{
    memset(visit, 0, sizeof(visit));
    for(int k = 1; k <= n; k++)
    {
        if(!lift[k][0]) dis[k][0] = 0;
    }
    while(1)
    {
        int mmin = INF, liftnum = -1, floor = -1;
        for(int k = 1; k <= n; k++)
        for(int j = 0; j < N; j++)
        {
            if(mk[k][j] && !visit[k][j] && dis[k][j] < mmin)
            {
                mmin = dis[k][j];
                floor = j;
                liftnum = k;
            }
        }
        //printf("dis[%d][%d] = %d\n", liftnum, floor, dis[liftnum][floor]);
        if(floor == floorK) return mmin;
        if(floor == -1) return INF;
        visit[liftnum][floor] = 1;
        for(int k = 1; k <= n; k++)
        for(int j = 0; j < N; j++)
        {
            if(mk[k][j] && !visit[k][j])
            {
                int tmp = dis[liftnum][floor] + g[k][floor][j];
                if(k == liftnum)
                {
                    if(tmp < dis[liftnum][j])
                        dis[liftnum][j] = tmp;
                }
                else if(j == floor)
                {
                //    printf("k = %d, j = %d\n", k, j);
                    if(tmp + 60 < dis[k][j])
                        dis[k][j] = tmp + 60;
                }
            }
        }
    }
}

int main()
{
  // freopen("in", "r", stdin);
    int n, floorK, t[N];
    char data[10 * N];
    while(~scanf("%d %d", &n, &floorK))
    {
        Init();

        for(int i = 1; i <= n; i++)
            scanf("%d", &t[i]);

        gets(data);
        for(int i = 1; i <= n; i++)
        {
            gets(data);
            char *p;
            top[i] = 0;
            p = strtok(data, " ");
            while(p)
            {
                int a;
                sscanf(p, "%d", &a);
                mk[i][a] = 1;
                lift[i][top[i]++] = a;
                p = strtok(NULL, " ");
            }
        }

        for(int k = 1; k <= n; k++)
        {
            for(int i = 0; i < top[k]; i++)
            for(int j = i + 1; j < top[k]; j++)
            {
                int a = lift[k][i], b = lift[k][j];
                g[k][a][b] = g[k][b][a] = (b - a) * t[k];
            //    printf("g[%d][%d][%d] = %d\n", k, a, b, g[k][a][b]);
            }
        }

        int ans = Dijkstra(n, floorK);
        if(ans == INF) puts("IMPOSSIBLE");
        else printf("%d\n", ans);
    }
    return 0;
}

Fucker 2010-09-14 16:06 发表评论

UVA 10278 Fire Station

Fucker — Tue, 14 Sep 2010 02:28:00 GMT

同PKU2607，脑子不灵活了，太久没思考问题了。这种当年秒杀的题目还写了好久。BS自己

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define N 505
#define INF 1 << 28

int g[N][N], station[N];
bool mk[N];

void Init(int n)
{
    memset(mk, 0, sizeof(mk));
    for(int i = 1; i <= n; i++)
    {
        g[i][i] = 0;
        for(int j = i + 1; j <= n; j++)
            g[i][j] = g[j][i] = INF;
    }
}

void Flyod(int n)
{
    for(int k = 1; k <= n; k++)
    {
        for(int i = 1; i <= n; i++)
        {
            if(i == k) continue;
            for(int j = 1; j <= n; j++)
            {
                if(i == j || j == k) continue;
                if(g[i][k] + g[k][j] < g[i][j])
                    g[i][j] = g[i][k] + g[k][j];
            }
        }
    }
}

int main()
{
   // freopen("in", "r", stdin);
    int t, f, n;
    char data[N];
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d %d", &f, &n);

        Init(n);

        for(int i = 0; i < f; i++)
        {
            scanf("%d", &station[i]);
            mk[station[i]] = 1;
        }

        gets(data);
        while(gets(data))
        {
            if(!strcmp(data, "")) break;
            int a, b, c;
            sscanf(data, "%d %d %d", &a, &b, &c);
        //    printf("%d %d %d\n", a, b, c);
            if(c < g[a][b]) g[a][b] = g[b][a] = c;
        }

        Flyod(n);

        int minlength, bestlength, anslength = INF, ans = 1;
        for(int i = 1; i <= n; i++)
        {
            if(mk[i]) continue;
            mk[i] = 1;
            station[f] = i;
            bestlength = -1;
            for(int j = 1; j <= n; j++)
            {
                if(mk[j]) continue;
                minlength = INF;
                for(int k = 0; k <= f; k++)
                {
                    if(g[j][station[k]] < minlength)
                    {
                        minlength = g[j][station[k]];
                    }
                }
                if(minlength > bestlength) bestlength = minlength;
            }
            mk[i] = 0;
            if(bestlength < anslength)
            {
                anslength = bestlength;
                ans = i;
            }
        }
        printf("%d\n", ans);
        if(t) printf("\n");
    }
    return 0;
}

Fucker 2010-09-14 10:28 发表评论

UVA 280 Vertex

Fucker — Sun, 12 Sep 2010 07:41:00 GMT

传递闭包水体，这都错3次，BS一下自己。

#include <stdio.h>
#include <string.h>

#define N 105

struct Matrix
{
    int mat[N][N];
};

void print(Matrix g, int n)
{
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= n; j++)
        {
            printf("%3d", g.mat[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

void Flyod_Warshall(Matrix &g, int n)
{
    for(int k = 1; k <= n; k++)
    {
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= n; j++)
            {
                g.mat[i][j] |= g.mat[i][k] & g.mat[k][j];
            }
        }
    }
}

int main()
{
    freopen("in", "r", stdin);
    int n, m, st, ed, ans[N], top;
    Matrix g;
    while(scanf("%d", &n), n)
    {
        memset(g.mat, 0, sizeof(g.mat));
        while(scanf("%d", &st), st)
        {
            while(scanf("%d", &ed), ed)
                g.mat[st][ed] = 1;
        }
        Flyod_Warshall(g, n);
        scanf("%d", &m);
        for(int i = 0; i < m; i++)
        {
            scanf("%d", &st);
            top = 0;
            for(int j = 1; j <= n; j++)
            {
                if(!g.mat[st][j])
                {
                    ans[top++] = j;
                }
            }
            printf("%d", top);
            for(int j = 0; j < top; j++)
                printf(" %d", ans[j]);
            printf("\n");
        }
    }
    return 0;
}

Fucker 2010-09-12 15:41 发表评论

UVA 10681 Teobaldo's Trip

Fucker — Sun, 12 Sep 2010 02:52:00 GMT

传递闭包，矩阵相乘。

#include <stdio.h>
#include <string.h>

#define N 105

struct Matrix
{
    int mat[N][N];
};

void print(Matrix g, int n)
{
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= n; j++)
        {
            printf("%3d", g.mat[i][j]);
        }
        printf("\n");
    }
}

Matrix MatrixMul(Matrix t, Matrix g, int n)
{
    Matrix ans;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= n; j++)
        {
            int sum = 0;
            for(int k = 1; k <= n; k++)
            {
                sum |= t.mat[i][k] & g.mat[k][j];
            }
            ans.mat[i][j] = sum;
        }
    }
    return ans;
}

Matrix MatrixPow(Matrix g, int n, int d)
{
    Matrix t;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= n; j++)
        {
            if(i == j) t.mat[i][j] = 1;
            else t.mat[i][j] = 0;
        }
    }
//    print(t, n);
    while(d)
    {
        if(d & 1) t = MatrixMul(t, g, n);
        g = MatrixMul(g, g, n);
        d >>= 1;
    }
    return t;
}

int main()
{
    //freopen("in", "r", stdin);
    int n, m, s, e, d;
    Matrix g;
    while(scanf("%d %d", &n, &m), n + m)
    {
        memset(g.mat, 0, sizeof(g.mat));
        for(int i = 0; i < m; i++)
        {
            scanf("%d %d", &s, &e);
            g.mat[s][e] = g.mat[e][s] = 1;
        }
        scanf("%d %d %d", &s, &e, &d);
        g = MatrixPow(g, n, d);
        if(g.mat[s][e]) puts("Yes, Teobaldo can travel.");
        else puts("No, Teobaldo can not travel.");
    }
    return 0;
}

Fucker 2010-09-12 10:52 发表评论

UVA 10461 Difference

Fucker — Sat, 24 Jul 2010 08:48:00 GMT

题意：给定一系列任务的依赖关系以及完成每个任务需要花费的时间，问一些任务的最晚完成时间和最早完成时间差值。

解法：根据依赖关系建立正反两个图，分别表示该任务动工之前需要完成哪些任务和哪些任务需要在该任务完成之后开始动工，然后两次dfs，分别标记任务，

然后剩下的没有标记的任务的就是完成时间就是所需要求的答案（具体见代码）。

#include <stdio.h>
#include <string.h>

#define N 505

bool g[N][N], gb[N][N], mk1[N], mk2[N];
int v[N];

void dfs1(int u, int n)
{
    mk1[u] = 1;
    for(int i = 1; i <= n; i++)
        if(!mk1[i] && g[u][i])
            dfs1(i, n);
}

void dfs2(int u, int n)
{
    mk2[u] = 1;
    for(int i = 1; i <= n; i++)
        if(!mk2[i] && gb[u][i])
            dfs2(i, n);
}

int main()
{
    int n, m, a, b, cas = 1;
    while(scanf("%d %d", &n, &m), n + m)
    {
        memset(g, 0, sizeof(g));
        memset(gb, 0, sizeof(gb));

        for(int i = 1; i <= n; i++)
            scanf("%d", &v[i]);

        for(int i = 0; i < m; i++)
        {
            scanf("%d %d", &a, &b);
            g[a][b] = 1;
            gb[b][a] = 1;
        }
        scanf("%d", &m);
        printf("Case #%d:\n", cas++);
        for(int i = 0; i < m; i++)
        {
            scanf("%d", &a);
            memset(mk1, 0, sizeof(mk1));
            memset(mk2, 0, sizeof(mk2));
            dfs1(a, n);
            dfs2(a, n);
            int count = 0;
            for(int j = 1; j <= n; j++)
            {
                if(!mk1[j] && !mk2[j])
                {
                    count += v[j];
                }
            }
            printf("%d\n", count);
        }
        puts("");
    }
    return 0;
}

Fucker 2010-07-24 16:48 发表评论

UVA 10305 Ordering Tasks

Fucker — Fri, 16 Jul 2010 03:17:00 GMT

拓扑排序。。还能比这再水一点么？

#include <stdio.h>
#include <string.h>

#define N 105

bool g[N][N];
int in[N];

void Topsort(int n)
{
    int front, top, queue[N * N];
    front = top = 0;
    for(int i = 1; i <= n; i++)
    {
        if(!in[i]) queue[top++] = i;
    }
    while(front < top)
    {
        int u = queue[front++];
        for(int i = 1; i <= n; i++)
        {
            if(g[u][i])
            {
                g[u][i] = 0;
                in[i]--;
                if(!in[i]) queue[top++] = i;
            }
        }
    }
    for(int i = 0; i < top; i++)
    {
        printf("%d", queue[i]);
        if(i != top - 1) printf(" ");
        else printf("\n");
    }
}

int main()
{
    int n, m;
    while(scanf("%d %d", &n, &m), n + m)
    {
        memset(g, 0, sizeof(g));
        memset(in, 0, sizeof(in));
        for(int i = 0; i < m; i++)
        {
            int a, b;
            scanf("%d %d", &a, &b);
            g[a][b] = 1;
            in[b]++;
        }
        Topsort(n);
    }
    return 0;
}

Fucker 2010-07-16 11:17 发表评论

UVA 796 Critical Links

Fucker — Fri, 16 Jul 2010 02:54:00 GMT

割边水题，套模板的题目。

#include <iostream>
#include <vector>
using namespace std;

const int N = 201;
bool bridge[N][N]; //bridge数组为1的说明是割边
int low[N], d[N];//Low数组保存最远祖先，d数组为深度
int color[N], bcnt;
vector<int> g[N];//用前需清空g[N]容器，bridge数组,color数组和bcnt

void dfs(int u, int parent, int deep )
{
    color[u] = 1;
    d[u] = low[u] = deep;
    for(int i = 0; i < g[u].size(); i++ )
    {
        int v = g[u][i];
        if(color[v] == 1 && v != parent)
            low[u] = low[u] < d[v] ? low[u] : d[v];
        if(color[v] == 0)
        {
            dfs(v, u, deep + 1);
            low[u] = low[u] < low[v] ? low[u] : low[v];
            if(low[v] > d[u])    //u v 是桥
            {
                bcnt++;
                bridge[u][v] = bridge[v][u] = 1;
            }
        }
    }
    color[u] = 2;
}

int main()
{
    int n;
    while(~scanf("%d", &n))
    {
        memset(bridge, false, sizeof(bridge));
        bcnt = 0;
        for(int i = 0; i < N; i++)
        {
            g[i].clear();
            color[i] = 0;
        }
        for(int i = 0; i < n; i++)
        {
            int a, b, c;
            scanf("%d (%d)", &a, &c);
            for(int j = 0; j < c; j++)
            {
                scanf("%d", &b);
                g[a].push_back(b);
                g[b].push_back(a);
            }
        }
        for(int i = 0; i < n; i++)
        {
            if(!color[i]) dfs(i, 0, 0);
        }
        printf("%d critical links\n", bcnt);
        for(int i = 0; i < n; i++)
        {
            for(int j = i + 1; j < n; j++)
            {
                if(bridge[i][j]) printf("%d - %d\n", i, j);
            }
        }
        printf("\n");
    }
    return 0;
}

Fucker 2010-07-16 10:54 发表评论

UVA 315 Network

Fucker — Fri, 16 Jul 2010 02:15:00 GMT

割点水题。。图论题基本就是套模板。。PS：输入有点点恶心，最讨厌的就是处理这中麻烦的输入了。。直接给出来明白的多。

#include <stdio.h>
#include <string.h>

const int N = 105;

int g[N][N];
int color[N], d[N], low[N];//color[]记录点的颜色 0:白色 1：灰色 2：黑色
bool cut[N];//d[]记录点的深度。low[]记录每个节点相连点的最小深度(最高祖先的深度),cut[]记录割点

void dfs(int k, int father, int deep, int n)
{
    int tot = 0;
    color[k] = 1;
    d[k] = low[k] = deep;
    for(int i = 1; i <= n; i++)
    {
        if(!g[k][i]) continue;
        int t = i;
        if(t != father && color[t] == 1)
           low[k] = low[k] < d[t] ? low[k] : d[t];
        if(color[t] == 0)
        {
           dfs(t, k, deep + 1, n);
           tot++;
           low[k] = low[k] < low[t] ? low[k] : low[t];
           if((k == 1 && tot > 1) || (k != 1 && low[t] >= d[k]))
               cut[k] = 1;
        }
    }
    color[k] = 2;
}

char data[1005];

int main()
{
    int n, a[N];
    while(scanf("%d", &n), n)
    {
        gets(data);
        memset(g, 0, sizeof(g));
        memset(cut, 0, sizeof(cut));
        memset(color, 0, sizeof(color));
        while(gets(data), strcmp(data, "0"))
        {
            int l = strlen(data);
            int b = 0, top = 0;
            for(int i = 0; i < l; i++)
            {
                if(data[i] >= '0' && data[i] <= '9') b = b * 10 + data[i] - '0';
                if(i + 1 == l || data[i + 1] == ' ')
                {
                //    printf("b = %d\n", b);
                    a[top++] = b;
                    b = 0;
                }
            }
            for(int i = 1; i < top; i++)
                g[a[0]][a[i]] = g[a[i]][a[0]] = 1;
        }
        dfs(1, 0, 0, n);
        int sum = 0;
        for(int i = 1; i <= n; i++)
        {
            if(cut[i]) sum++;
        }
        printf("%d\n", sum);
    }
    return 0;
}

Fucker 2010-07-16 10:15 发表评论

UVA 563 Crimewave

Fucker — Wed, 14 Jul 2010 11:04:00 GMT

逃脱问题，在算法导论网络流后面的习题里面有提到，就是一个点不相交的路径，要拆点，导致图很大，我的邻接矩阵isap超时，换成邻接表还是超时。。

就拿人家的代码交了，思想还是简单的。我的网路流模板当图一大就超时。。真杯具。

#include <iostream>
#include <vector>
#include <queue>
// 50 * 50 * 2 + 2 = 5002
#define MAX 5002
#define RESIDUE(s,t) (capacity[s][t]-flow[s][t])

using namespace std;

int dr[4] = {0, 1, 0, -1};
int dc[4] = {1, 0, -1, 0};
int bank[MAX][2];
int flow[MAX][MAX];
int capacity[MAX][MAX];
int s, a, b;
int prev[MAX];

inline int getSourceID() { return s * a * 2; }
inline int getDestinationID() { return s * a * 2 + 1; }
inline int getIDByRowCol(int r, int c, int rank) { return r * a + c + rank * s * a; }
inline void getRowColByID(int id, int &row, int &col, int &rank) {
  rank = id >= s * a; id %= s * a;
  row = id / a;
  col = id % a;
}
inline bool isValid(int r, int c) { return 0 <= r && r < s && 0 <= c && c < a; }
inline bool isOnEdge(int r, int c) { return r == 0 || r == s - 1 || c == 0 || c == a - 1; }

void display(int id) {
  if (prev[id] != id) {
    display(prev[id]);
  }
  if (id == getSourceID()) {
    cout << "source" << endl;
  } else if (id == getDestinationID()) {
    cout << "destination" << endl;
  } else {
    int row, col, rank;
    getRowColByID(id, row, col, rank);
    cout << row + 1 << " " << col + 1;
    if (rank) cout << " shadow";
    cout << endl;
  }
}

main () {
  int p;
  cin >> p;
  for (int P = 0; P < p; ++P) {
    // Input
    cin >> s >> a >> b;
    for (int i = 0; i < b; ++i) {
      cin >> bank[i][0] >> bank[i][1];
      bank[i][0]--, bank[i][1]--;
    }

    // Initialize
    memset(capacity, 0, sizeof(capacity));
    memset(flow, 0, sizeof(flow));
    // Source to banks
    for (int i = 0; i < b; ++i) {
      capacity[getSourceID()][getIDByRowCol(bank[i][0], bank[i][1], 0)] = 1;
    }
    // Adjacent grid
    for (int i = 0; i < s; ++i) {
      for (int j = 0; j < a; ++j) {
        int fromID = getIDByRowCol(i, j, 0);
        int _fromID = getIDByRowCol(i, j, 1);
        capacity[_fromID][fromID] = 1;
        for (int k = 0; k < 4; ++k) {
          int ni = i + dr[k];
          int nj = j + dc[k];
          if (!isValid(ni, nj)) continue;
          int toID = getIDByRowCol(ni, nj, 1);
          capacity[fromID][toID] = 1;
        }
      }
    }
    // Grids on edge to destination
    for (int i = 0; i < s; ++i) {
      capacity[getIDByRowCol(i, 0, 0)][getDestinationID()] = 1;
      capacity[getIDByRowCol(i, a - 1, 0)][getDestinationID()] = 1;
    }
    for (int j = 0; j < a; ++j) {
      capacity[getIDByRowCol(0, j, 0)][getDestinationID()] = 1;
      capacity[getIDByRowCol(s - 1, j, 0)][getDestinationID()] = 1;
    }
    // If a bank exists on a corner, transition between
    // surface and shadow is forbidden.
    for (int i = 0; i < b; ++i) {
      capacity[getIDByRowCol(bank[i][0], bank[i][1], 1)][getIDByRowCol(bank[i][0], bank[i][1], 0)] = 0;
    }

    // Maxflow
    int total = 0;
    while (1) {
      queue<int> que; que.push(getSourceID());
      memset(prev, -1, sizeof(prev)); prev[getSourceID()] = getSourceID();
      while (!que.empty() && prev[getDestinationID()] == -1) {
        int u = que.front(); que.pop();
        vector<int> nextID;
        if (u == getSourceID()) {
          for (int i = 0; i < b; ++i) {
            //cout << bank[i][0] << " " << bank[i][1] << ", id = " << getIDByRowCol(bank[i][0], bank[i][1], 0) << endl;
            nextID.push_back(getIDByRowCol(bank[i][0], bank[i][1], 0));
          }
        } else {
          int row, col, rank;
          getRowColByID(u, row, col, rank);
          //cout << u << " " << row << " " << col << " " << rank << endl;
          if (rank == 0 && isOnEdge(row, col)) {
            nextID.push_back(getDestinationID());
          } else if (rank == 1) {
            nextID.push_back(getIDByRowCol(row, col, 0));
          } else {
            for (int i = 0; i < 4; ++i) {
              int nrow = row + dr[i];
              int ncol = col + dc[i];
              if (!isValid(nrow, ncol)) continue;
              nextID.push_back(getIDByRowCol(nrow, ncol, 1));
            }
          }
        }
        for (int i = 0; i < nextID.size(); ++i) {
          int v = nextID[i];
          if (prev[v] == -1 && RESIDUE(u, v) > 0) {
            prev[v] = u;
            que.push(v);
          }
        }
      }
      if (prev[getDestinationID()] == -1) break;
      int inc = INT_MAX;
      for (int j = getDestinationID(); prev[j] != j; j = prev[j]) {
        inc = min(inc, RESIDUE(prev[j], j));
      }
      for (int j = getDestinationID(); prev[j] != j; j = prev[j]) {
        flow[prev[j]][j] += inc, flow[j][prev[j]] -= inc;
      }
      //display(getDestinationID()); cout << endl;
      total += inc;
    }
    //cout << total << endl;
    if (total == b) {
      cout << "possible" << endl;
    } else {
      cout << "not possible" << endl;
    }
  }
}

Fucker 2010-07-14 19:04 发表评论

UVA 10330 Power Transmission

Fucker — Wed, 14 Jul 2010 09:17:00 GMT

网络流水题。。点有容量，那就拆点，有多个源点和汇点，那就新引入源点和汇点，再求最大流。

这种太裸的题目基本上是拿来练手的。

#include <iostream>
using namespace std;

#define N 205
#define INF 1 << 29

int cap[N][N], dis[N], pre[N], cnt[N];

int ISAP(int src, int sink, int n)
{
    int maxflow = 0, flow, u = src, v, d;
    memset(dis, 0, sizeof(dis));
    memset(cnt, 0, sizeof(cnt));
    pre[src] = src;
    cnt[src] = n;
    while(dis[src] < n)
    {
        if(u == sink)
        {
            flow = INF;
            for(int i = sink; i != src; i = pre[i])
                if(cap[pre[i]][i] < flow)
                    flow = cap[pre[i]][i];
            maxflow += flow;
            u = src;
            for(int i = sink; i != src; i = pre[i])
            {
                cap[pre[i]][i] -= flow;
                cap[i][pre[i]] += flow;
            }
        }
        for(d = n, v = 0; v < n; v++)
        {
            if(!cap[u][v]) continue;
            d = d < dis[v] ? d : dis[v];
            if(dis[v] + 1 == dis[u]) break;
        }
        if(v < n) pre[v] = u, u = v;
        else
        {
            if(!(--cnt[dis[u]])) break;
            ++cnt[dis[u] = d + 1];
            if(u != src) u = pre[u];
        }
    }
    return maxflow;
}

int main()
{
    int n, m, a, b, c, st, ed, cas = 1;
    while(~scanf("%d", &n))
    {
        st = 0, ed = (n << 1) + 1;
        memset(cap, 0, sizeof(cap));
        for(int i = 1; i <= n; i++)
        {
            scanf("%d", &a);
            cap[i][i + n] = a;
        }
        scanf("%d", &m);
        for(int i = 0; i < m; i++)
        {
            scanf("%d %d %d", &a, &b, &c);
            if(a == b) continue;
            cap[a + n][b] += c;
        }
        scanf("%d %d", &a, &b);
        for(int i = 0; i < a; i++)
        {
            scanf("%d", &c);
            cap[st][c] = INF;
        }
        for(int i = 0; i < b; i++)
        {
            scanf("%d", &c);
            cap[c + n][ed] = INF;
        }
        int ans = ISAP(st, ed, ed + 1);
        printf("%d\n", ans);
    }
    return 0;
}

Fucker 2010-07-14 17:17 发表评论

UVA 820 Internet Bandwidth

Fucker — Tue, 13 Jul 2010 14:44:00 GMT

网络流水题。。Network写成Netword导致WA了两次杯具。

#include <iostream>
using namespace std;

#define N 105
#define INF INT_MAX

int cap[N][N], dis[N], pre[N], cnt[N];

int ISAP(int src, int sink, int n)
{
    int maxflow = 0, flow, u = src, v, d;
    memset(dis, 0, sizeof(dis));
    memset(cnt, 0, sizeof(cnt));
    pre[src] = src;
    cnt[src] = n;
    while(dis[src] < n)
    {
        if(u == sink)
        {
            flow = INF;
            for(int i = sink; i != src; i = pre[i])
                if(cap[pre[i]][i] < flow)
                    flow = cap[pre[i]][i];
            maxflow += flow;
            u = src;
            for(int i = sink; i != src; i = pre[i])
            {
                cap[pre[i]][i] -= flow;
                cap[i][pre[i]] += flow;
            }
        }
        for(d = n, v = 0; v < n; v++)
        {
            if(!cap[u][v]) continue;
            d = d < dis[v] ? d : dis[v];
            if(dis[v] + 1 == dis[u]) break;
        }
        if(v < n) pre[v] = u, u = v;
        else
        {
            if(!(--cnt[dis[u]])) break;
            ++cnt[dis[u] = d + 1];
            if(u != src) u = pre[u];
        }
    }
    return maxflow;
}

int main()
{
    int n, m, st, ed, cas = 1;
    while(scanf("%d", &n), n)
    {
        memset(cap, 0, sizeof(cap));
        scanf("%d %d %d", &st, &ed, &m);
        for(int i = 0; i < m; i++)
        {
            int a, b, c;
            scanf("%d %d %d", &a, &b, &c);
            a--, b--;
            cap[a][b] += c;
            cap[b][a] += c;
        }
        int ans = ISAP(st - 1, ed - 1, n);
        printf("Network %d\n", cas++);
        printf("The bandwidth is %d.\n\n", ans);
    }
    return 0;
}

Fucker 2010-07-13 22:44 发表评论

UVA 10806 Dijkstra, Dijkstra.

Fucker — Sun, 11 Jul 2010 01:56:00 GMT

和SGU 185 Two shortest有点类似。。就是求从源点到终点的再从终点到源点的最短路，但是不能经过同一条边两次。

费用流，原来边的长度作为花费，容量为1，再建新源点到旧源点容量为2，新汇点和旧汇点容量为2，求最小费用就为最短路径。如果不存在则新源点到旧源点的容量小于2。

这题貌似也有多种解法。费用流不唯一。

#include <iostream>
using namespace std;

#define N 105
#define INF 1 << 29

struct node
{
    int cap, cost;
}g[N][N];

int pre[N], d[N], map[N][N];

bool spfa(int src, int sink)
{
    int que[N * N], front, top, u;
    bool in[N];
    for(int i = 0; i <= sink; i++)
    {
        d[i] = INF;
        in[i] = 0;
    }
    in[src] = 1;
    d[src] = front = top = 0;
    pre[src] = src;
    que[top++] = src;
    while(front < top)
    {
        u = que[front++];
        in[u] = 0;
        for(int i = 0; i <= sink; i++)
        {
            if(g[u][i].cap > 0 && d[u] + g[u][i].cost < d[i])
            {
                d[i] = d[u] + g[u][i].cost;
                pre[i] = u;
                if(!in[i])
                {
                    que[top++] = i;
                    in[i] = 1;
                }
            }
        }
    }
    return d[sink] != INF;
}

int mincost(int src, int sink)
{
    int ans = 0, flow;
    while(spfa(src, sink))
    {
        flow = INF;
        for(int i = sink; i != src; i = pre[i])
        {
            if(flow > g[pre[i]][i].cap)
                flow = g[pre[i]][i].cap;
        }
        for(int i = sink; i != src; i = pre[i])
        {
            g[pre[i]][i].cap -= flow;
            g[i][pre[i]].cap += flow;
            g[i][pre[i]].cost = -g[pre[i]][i].cost;
        }
        ans += d[sink] * flow;
    }
    return ans;
}

int main()
{
    int n, m, ans;
    while(scanf("%d", &n), n)
    {
        scanf("%d", &m);
        memset(g, 0, sizeof(g));
        for(int i = 0; i < m; i++)
        {
            int a, b, c;
            scanf("%d %d %d", &a, &b, &c);
            g[a][b].cap = g[b][a].cap = 1;
            g[a][b].cost = g[b][a].cost = c;
        }
        g[0][1].cap = g[1][0].cap = 2;
        g[n][n + 1].cap = g[n + 1][n].cap = 2;
        ans = mincost(0, n + 1);
        if(g[0][1].cap) puts("Back to jail");
        else printf("%d\n", ans);
    }
    return 0;
}

Fucker 2010-07-11 09:56 发表评论

UVA 11594 All Pairs Maximum Flow

Fucker — Fri, 09 Jul 2010 09:38:00 GMT

很裸的题目，即求所有点对之间的最小割。有Gomory-Hu和Gusfield两种算法，貌似Gomory-Hu的难实现一点，效率搞一点，Gusfield的容易实现一点，但是效率没那么高？

看着网上的伪代码写出来的。。具体论文还没有仔细看。

贴出论文Dan Gusfield: Very Simple Methods for All Pairs Network Flow Analysis. SIAM J. Comput. 19(1): 143-155 (1990)

#include <iostream>
using namespace std;

#define N 205
#define INF 1 << 28

int g[N][N], mk[N];
int cap[N][N], dis[N], pre[N], cnt[N];

int ISAP(int src, int sink, int n)
{
    int maxflow = 0, flow, u = src, v, d;
    memset(dis, 0, sizeof(dis));
    memset(cnt, 0, sizeof(cnt));
    pre[src] = src;
    cnt[src] = n;
    while(dis[src] < n)
    {
        if(u == sink)
        {
            flow = INF;
            for(int i = sink; i != src; i = pre[i])
                if(cap[pre[i]][i] < flow)
                    flow = cap[pre[i]][i];
            maxflow += flow;
            u = src;
            for(int i = sink; i != src; i = pre[i])
            {
                cap[pre[i]][i] -= flow;
                cap[i][pre[i]] += flow;
            }
        }
        for(d = n, v = 0; v < n; v++)
        {
            if(!cap[u][v]) continue;
            d = d < dis[v] ? d : dis[v];
            if(dis[v] + 1 == dis[u]) break;
        }
        if(v < n) pre[v] = u, u = v;
        else
        {
            if(!(--cnt[dis[u]])) break;
            ++cnt[dis[u] = d + 1];
            if(u != src) u = pre[u];
        }
    }
    return maxflow;
}

int parent[N], cut[N][N];

void dfs(int u, int n)
{
    mk[u] = 1;
    for(int i = 0; i < n; i++)
    {
        if(!mk[i] && cap[u][i])
            dfs(i, n);
    }
}

void Solve(int n)
{
    memset(parent, 0, sizeof(parent));
    memset(cut, 127, sizeof(cut));
    for(int i = 1; i < n; i++)
    {
        memset(mk, 0, sizeof(mk));
        memcpy(cap, g, sizeof(g));
        int mincut = ISAP(i, parent[i], n);
        dfs(i, n);
        for(int j = i + 1; j < n; j++)
            if(mk[j] && parent[j] == parent[i])
            {
                parent[j] = i;
            }
        cut[i][parent[i]] = cut[parent[i]][i] = mincut;
        for(int j = 0; j < i; j++)
            cut[i][j] = cut[j][i] = min(mincut, cut[parent[i]][j]);
    }

    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            if(i == j) cut[i][j] = 0;
            printf("%d", cut[i][j]);
            if(j != n - 1) printf(" ");
        }
        printf("\n");
    }
}

int main()
{
    int t, n, cas = 1;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d", &n);
        for(int i = 0; i < n; i++)
        for(int j = 0; j < n; j++)
            scanf("%d", &g[i][j]);
        printf("Case #%d:\n", cas++);
        Solve(n);
    }
    return 0;
}

Fucker 2010-07-09 17:38 发表评论

UVA 10989 Bomb, Divide and Conquer

Fucker — Wed, 07 Jul 2010 14:01:00 GMT

全局最小割，和PKU 2914 minimun cut一样。直接上模板。

#include <stdio.h>
#include <string.h>

#define N 155
#define INF 1 << 28
#define MIN(a, b) (a < b ? a : b)

int g[N][N], w[N];
bool visit[N], del[N];

int Stoer_Wagner(int n)
{
    int mincut = INF;
    int st = 1;
    memset(del, 0, sizeof(del));
    for(int i = 1; i < n; i++)
    {

        for(int j = 1; j <= n; j++)
            if(!del[j])
            {
                w[j] = g[st][j];
            }

        int mmin, cur = st, pre;
        memset(visit, 0, sizeof(visit));
        visit[st] = 1;

        for(int j = 1; j <= n - i; j++)
        {
            mmin = -INF, pre = cur, cur = 0;
            for(int k = 1; k <= n; k++)
                if(!del[k] && !visit[k] && w[k] > mmin)
                {
                    cur = k;
                    mmin = w[k];
                }

            if(!cur) return 0;
            visit[cur] = 1;

            for(int k = 1; k <= n; k++)
                if(!del[k] && !visit[k])
                {
                    w[k] += g[cur][k];
                }
        }

        mincut = MIN(mincut, w[cur]);
        del[cur] = 1;

        for(int j = 1; j <= n; j++)
            if(!del[j] && j != pre)
            {
                g[j][pre] += g[j][cur];
                g[pre][j] += g[cur][j];
            }
    }
    return mincut;
}

int main()
{
    int cas = 1, t, n, m;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d %d", &n, &m);
        memset(g, 0, sizeof(g));
        for(int i = 0; i < m; i++)
        {
            int a, b, c;
            scanf("%d %d %d", &a, &b, &c);
            g[a][b] += c;
            g[b][a] += c;
        }
        printf("Case #%d: %d\n", cas++, Stoer_Wagner(n));
    }
    return 0;
}

Fucker 2010-07-07 22:01 发表评论

PKU 2814 Minimum Cut

Fucker — Wed, 07 Jul 2010 11:31:00 GMT

无向图全局最小割。Stoer_Wagner算法。只会用，具体证明还没弄懂，我这代码很挫啊，跑了9秒。

#include <stdio.h>
#include <string.h>

#define N 505
#define INF 1 << 28
#define MIN(a, b) (a < b ? a : b)

int g[N][N], w[N];
bool visit[N], del[N];

int Stoer_Wagner(int n)
{
    int mincut = INF;
    int src = 1;
    memset(del, 0, sizeof(del));
    for(int i = 1; i < n; i++) //n - 1次合并
    {
        for(int j = 1; j <= n; j++)
            if(!del[j])
            {
                w[j] = g[src][j];
            }

        memset(visit, 0, sizeof(visit));
        visit[src] = 1;
        int mmin, cur = src, pre;

        for(int j = 1; j <= n - i; j++)
        {
            mmin = -INF, pre = cur, cur = 0;
            for(int k = 1; k <= n; k++)
                if(!del[k] && !visit[k] && w[k] > mmin)
                {
                    cur = k;
                    mmin = w[k];
                }

            if(!cur) return 0; //不连通
            visit[cur] = 1;

            for(int k = 1; k <= n; k++)
                if(!del[k] && !visit[k])
                {
                    w[k] += g[cur][k];
                }
        }

        mincut = MIN(mincut, w[cur]);
        del[cur] = 1;

        for(int j = 1; j <= n; j++)
            if(!del[j] && j != pre)
            {
                g[j][pre] += g[j][cur];
                g[pre][j] += g[cur][j];
            }
    }
    return mincut;
}

int main()
{
    int n, m, ans;
    while(~scanf("%d %d", &n, &m))
    {
        memset(g, 0, sizeof(g));
        for(int i = 0; i < m; i++)
        {
            int a, b, c;
            scanf("%d %d %d", &a, &b, &c);
            if(a == b) continue;
            a++, b++;
            g[a][b] += c;
            g[b][a] += c;
        }

        ans = Stoer_Wagner(n);
        printf("%d\n", ans);
    }
    return 0;
}

Fucker 2010-07-07 19:31 发表评论

UVA 10480 Sabotage

Fucker — Wed, 07 Jul 2010 08:39:00 GMT

题意：给定多个城市的网络，每个城市之间的通信有花费，要求使得首都和最大城市之间的通信断掉的最小花费。要求输出砸掉的边。

解法：给出了源点和汇点，果断最小割。也许是许久没有写图论的题了，最小割输出出错，忘记了可能有多个最小割存在。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define N 55
#define INF 1 << 28

int cap[N][N], dis[N], pre[N], cnt[N];
bool g[N][N], mk[N];

int ISAP(int src, int sink, int n)
{
    int maxflow = 0, flow, u = src, v, d;
    for(int i = 0; i < n; i++)
        dis[i] = cnt[i] = 0;
    pre[src] = src;
    cnt[src] = n;
    while(dis[src] < n)
    {
        if(u == sink)
        {
            flow = INF;
            for(int i = sink; i != src; i = pre[i])
                if(cap[pre[i]][i] < flow)
                    flow = cap[pre[i]][i];
            maxflow += flow;
            u = src;
            for(int i = sink; i != src; i = pre[i])
            {
                cap[pre[i]][i] -= flow;
                cap[i][pre[i]] += flow;
            }
        }
        for(d = n, v = 0; v < n; v++)
        {
            if(!cap[u][v]) continue;
            d = d < dis[v] ? d : dis[v];
            if(dis[v] + 1 == dis[u]) break;
        }
        if(v < n) pre[v] = u, u = v;
        else
        {
            if(!(--cnt[dis[u]])) break;
            ++cnt[dis[u] = d + 1];
            u = pre[u];
        }
    }
    return maxflow;
}

void Dfs(int u, int n)
{
    mk[u] = 1;
    for(int i = 0; i < n; i++)
    {
        if(!mk[i] && cap[u][i]) Dfs(i, n);
    }
}

int main()
{
    int n, m;
    while(scanf("%d %d", &n, &m), n + m)
    {
        memset(cap, 0, sizeof(cap));
        memset(g, 0, sizeof(g));
        memset(mk, 0, sizeof(mk));
        for(int i = 0; i < m; i++)
        {
            int a , b, c;
            scanf("%d %d %d", &a, &b, &c);
            a--, b--;
            cap[a][b] = cap[b][a] = c;
            g[a][b] = g[b][a] = 1;
        }
        int ans = ISAP(0, 1, n);
        Dfs(0, n);
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(g[i][j] && !cap[i][j] && mk[i] != mk[j])
                    printf("%d %d\n", i + 1, j + 1);
            }
        }
        printf("\n");
    }
    return 0;
}

Fucker 2010-07-07 16:39 发表评论

PKU 1125 Stockbroker Grapevine

Fucker — Sat, 12 Jun 2010 10:21:00 GMT

题意：在一个带全有向图中找一点使其道其它所有点的最短距离最大的那个最小。

解法：flyod+枚举点，没觉着和DP有什么关系。

#include <stdio.h>

#define N 105
#define INF 1 << 28

int g[N][N], mark[N];

void floyd(int n)
{
    for(int k = 1; k <= n; k++)
    for(int i = 1; i <= n; i++)
    {
        if(i == k) continue;
        for(int j = 1; j <= n; j++)
        {
            if(j == k || i == j) continue;
            if(g[i][k] + g[k][j] < g[i][j])
            {
                g[i][j] = g[i][k] + g[k][j];
            }
        }
    }
}

void dfs(int u, int n)
{
    mark[u] = 1;
    for(int i = 1; i <= n; i++)
    {
        if(!mark[i]) dfs(i, n);
    }
}

int main()
{
    int n, m, a, b, dis;
    while(scanf("%d", &n), n)
    {
        for(int i = 1; i <= n; i++)
        {
            g[i][i] = mark[i] = 0;
            for(int j = i + 1; j <= n; j++)
                g[i][j] = g[j][i] = INF;
        }
        for(int i = 1; i <= n; i++)
        {
            scanf("%d", &m);
            for(int j = 0; j < m; j++)
            {
                scanf("%d %d", &a, &b);
                if(b < g[i][a]) g[i][a] = b;
            }
        }
        dfs(1, n);
        bool flag = 0;
        for(int i = 1; i <= n; i++)
        {
            if(!mark[i])
            {
                flag = 1;
                break;
            }
        }
        if(flag)
        {
            printf("disjoint");
            continue;
        }
        floyd(n);
        dis = INF;
        for(int i = 1; i <= n && mark; i++)
        {
            b = -INF;
            for(int j = 1; j <= n && mark; j++)
            {
                if(i == j) continue;
                if(g[i][j] > b) b = g[i][j];
            }
            if(b < dis) a = i, dis = b;
        }
        printf("%d %d\n", a, dis);
    }
    return 0;
}

Fucker 2010-06-12 18:21 发表评论

HOJ 10940 Coconuts

Fucker — Mon, 24 May 2010 02:57:00 GMT

我勒个擦，我们OJ竟然还有我没做的网络流的题目，昨天在dsh的推荐下，今天试着写了一下，题目，由于事先已经知道是最小割了，所以建模没有什么太大的难度了。

解法：朋友之间连边，从源点到相信African swallow可以carry coconuts的人连边，否则从这个人到汇点连边，容量都为1，主义朋友之间连双向边，求最大流(最小割)即为结果。

#include <stdio.h>
#include <string.h>

#define N 305
#define INF 1 << 29

int g[N][N], cnt[N], dis[N], pre[N];

void Pre()
{
    memset(g, 0, sizeof(g));
}

int ISAP(int src, int sink, int n)
{
    int maxflow = 0, flow, u = src, v, d;
    memset(cnt, 0, sizeof(cnt));
    memset(dis, 0, sizeof(dis));
    pre[src] = src;
    cnt[0] = n;
    while(dis[src] < n)
    {
        if(u == sink)
        {
            flow = INF;
            for(int i = sink; i != src; i = pre[i])
                if(g[pre[i]][i] < flow)
                {
                    flow = g[pre[i]][i];
                }
            maxflow += flow;
            u = src;
            for(int i = sink; i != src; i = pre[i])
            {
                g[pre[i]][i] -= flow;
                g[i][pre[i]] += flow;
            }
        }
        for(d = n, v = 0; v < n; v++)
        {
            if(!g[u][v]) continue;
            d = d < dis[v] ? d : dis[v];
            if(dis[v] + 1 == dis[u]) break;
        }
        if(v < n) pre[v] = u, u = v;
        else
        {
            if(!(--cnt[dis[u]])) break;
            ++cnt[dis[u] = d + 1];
            u = pre[u];
        }
    }
    return maxflow;
}

int main()
{
    int n, m, src, sink, a, b, c;
    while(scanf("%d %d", &n, &m), n + m)
    {
        Pre();
        src = 0, sink = n + 1;
        for(int i = 1; i <= n; i++)
        {
            scanf("%d", &c);
            if(c) g[src][i] = 1;
            else g[i][sink] = 1;
        }
        for(int i = 0; i < m; i++)
        {
            scanf("%d %d", &a, &b);
            g[a][b] = g[b][a] = 1;
        }
        int ans = ISAP(src, sink, n + 2);
        printf("%d\n", ans);
    }
    return 0;
}

Fucker 2010-05-24 10:57 发表评论

HOJ 11723 World Exposition's Puzzle

Fucker — Mon, 24 May 2010 01:51:00 GMT

校赛题,比赛的时候没有仔细想，现在回想就是一个二维最短路，貌似和上次09年月赛俊神出的那道trip解法类似。。。

#include <stdio.h>
#include <string.h>

#define N 105
const long long INF = 1LL << 60;

long long g[N][N], dis[11][N];
bool mark[11][N];

void Pre()
{
    for(int i = 0; i < N; i++)
    {
        for(int j = 0; j < N; j++)
        {
            g[i][j] = INF;
        }
        for(int j = 0; j < 11; j++)
        {
            dis[j][i] = INF;
        }
    }
}

long long Dijkstra(int st, int ed, int x, int n)
{
    memset(mark, 0, sizeof(mark));
    dis[0][st] = 0;
    for(int i = 0; i < x * n; i++)
    {
        long long mmin = INF;
        int u = -1, cur, next;
        for(int j = 0; j < n; j++)
        {
            for(int k = 0; k < x; k++)
            {
                if(!mark[k][j] && dis[k][j] < mmin)
                {
                    mmin = dis[k][j];
                    u = j;
                    cur = k;
                    next = (k + 1) % x;
                }
            }
        }
        if(-1 == u) return -1;
        //printf("u = %d, cur = %d\n", u, cur);
        mark[cur][u] = 1;
        if(mark[0][ed]) return dis[0][ed];
        for(int j = 0; j < n; j++)
        {
            if(!mark[next][j] && dis[cur][u] + g[u][j] < dis[next][j])
            {
                dis[next][j] = dis[cur][u] + g[u][j];
                //printf("next = %d, j = %d\n", next, j);
            }
        }
    }
}

int main()
{
    int t, n, m, st, ed, x;
    scanf("%d", &t);
    while(t--)
    {
        Pre();
        scanf("%d %d", &n, &m);
        for(int i = 0; i < m; i++)
        {
            int a, b, c;
            scanf("%d %d %d", &a, &b, &c);
            if(c < g[a][b]) g[a][b] = c;
        }
        scanf("%d %d %d", &st, &ed, &x);
        long long ans = Dijkstra(st, ed, x, n);
        if(-1 == ans) printf("No Answer!\n");
        else printf("%I64d\n", ans);
    }
    return 0;
}

Fucker 2010-05-24 09:51 发表评论

HDU 3231 Box Relations

Fucker — Sat, 22 May 2010 15:57:00 GMT

摘要: 去年武汉现场赛的题目，当时想法都对了死活没写出来，惭愧，其实很简单，判环还想复杂了，其实构造好图后就一个拓扑排序就行了。解法：处理好一维的，三维就一样，什么bellmanford完全不用，直接拓扑排序。#include #include #include #define&nb... 阅读全文

Fucker 2010-05-22 23:57 发表评论

HIT 2913 The Coolest Search Engine

Fucker — Thu, 20 May 2010 10:03:00 GMT

去年哈尔滨网络预选赛的一道题目,当初题目没有读懂，Yi大牛用浙大KM板子A掉此题。心中一直留有遗憾，回头再看，发现建模是如此重要。数与图的结合还是很紧密的。

题意:给出一个集合U,和一些搜索引擎对该集合的排序，要求出一个最酷的引擎，该搜索引擎的结果满足条件其中。

解法:该搜索引擎的结果总数是集合U大小的排列，集合U最大有100，所以枚举是肯定不行的。此题的建模我觉得还是挺巧妙地，因为题目中要求的值F(A,B1,...,Bm)是A的排序结果和其它B的排序结果的差值总和，这样对于集合U中的每个元素建立一个节点，建立二分图，左边代表所有B的第i个列,右边为集合U的数值(从0到n-1),对于左边的每一列求出对应的所有的B的i列与右边节点所有值的差的绝对值,然后用KM求出该图的最小匹配即可。理解:只需要求出F(A,B1,...,Bm)的最小值，无需求出A的排列结果，所以对应A中的每一个元素都和B有一个差值，所以只需求出这个最小的差值即可。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define N 105
#define INF 1 << 28
#define MAX(a, b) (a > b ? a : b)
#define MIN(a, b) (a < b ? a : b)

inline int ABS(int x)
{
    return x > 0 ? x:-x;
}

int match[N], x[N], y[N];
int lx[N], ly[N], g[N][N];

bool dfs(int u, int n)
{
    x[u] = 1;
    for(int i = 0; i < n; i++)
    {
        int wt = lx[u] + ly[i] - g[u][i];
        if(!y[i] && !wt)
        {
            y[i] = 1;
            if(match[i] == -1 || dfs(match[i], n))
            {
                match[i] = u;
                return 1;
            }
        }
    }
    return 0;
}

int KM(int n)
{
    memset(ly, 0, sizeof(ly));
    memset(match, -1, sizeof(match));
    for(int i = 0; i < n; i++)
    {
        lx[i] = -INF;
        for(int j = 0; j < n; j++)
            lx[i] = MAX(lx[i], g[i][j]);
    }
    for(int k = 0; k < n; k++)
    {
        memset(x, 0, sizeof(x));
        memset(y, 0, sizeof(y));
        while(!dfs(k, n))
        {
            int d = INF;
            for(int i = 0; i < n; i++)
                if(x[i])
                    for(int j = 0; j < n; j++)
                        if(!y[j])
                            d = MIN(d, lx[i] + ly[j] - g[i][j]);
            for(int i = 0; i < n; i++)
            {
                if(x[i]) lx[i] -= d, x[i] = 0;
                if(y[i]) ly[i] += d, y[i] = 0;
            }
        }
    }
    int sum = 0;
    for(int i = 0; i < n; i++)
        sum += g[match[i]][i];
    return sum;
}

int main()
{
    int t, n, m, b[N][N];
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d %d", &n, &m);
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
            {
                scanf("%d", &b[i][j]);
            }
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < n; j++)
            {
                g[i][j] = 0;
                for(int k = 0; k < m; k++)
                {
                    g[i][j] -= ABS(b[k][i] - j);
                }
            }
        }
        int ans = -KM(n);
        printf("%d\n", ans);
    }
    return 0;
}

Fucker 2010-05-20 18:03 发表评论

SGU 101 Domino

Fucker — Thu, 20 May 2010 02:40:00 GMT

现在开始转战SGU,接着水题。

解法：欧拉路，模型很容易想到，记得UVA上有一道类似的叫The necklace。题目虽然简单，细节的调试花了我不少时间，手感还没恢复啊。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define N 105

int p1[N], p2[N], g[10][10], d[N], ans[N], top;

void Pre()
{
    top = 0;
    memset(g, 0, sizeof(g));
    memset(d, 0, sizeof(d));
    memset(p1, -1, sizeof(p1));
    memset(p2, -1, sizeof(p2));
}

void Euler(int u)
{
    for(int i = 0; i < 7; i++)
        if(g[u][i])
        {
            g[u][i]--, g[i][u]--;
            d[i]--, d[u]--;
            Euler(i);
        }
    ans[top++] = u;
}

void Solve(int n)
{
    int odd = 0, u;
    for(int i = 0; i < 7; i++)
    {
        if(d[i] & 1)
        {
            odd++;
            u = i;
        }
    }
    if(odd && odd != 2)
    {
        puts("No solution");
        return;
    }
    for(int i = 0; i < 7; i++)
    {
        if(odd)
        {
            if(d[i] & 1)
            {
                Euler(i);
                break;
            }
        }
        else if(d[i])
        {
            Euler(i);
            break;
        }
    }
    if(top != n + 1)
    {
        puts("No solution");
        return;
    }
    for(int k = 1; k < top; k++)
    {
        int a, b;
        a = ans[k - 1], b = ans[k];
        for(int i = 0; i < n; i++)
        {
            if(a == p1[i] && b == p2[i])
            {
                printf("%d +\n", i + 1);
                p1[i] = p2[i] = -1;
                break;
            }
            else if(a == p2[i] && b == p1[i])
            {
                printf("%d -\n", i + 1);
                p1[i] = p2[i] = -1;
                break;
            }
        }
    }
}

int main()
{
    int n, a, b;
    while(~scanf("%d", &n))
    {
        Pre();
        for(int i = 0; i < n; i++)
        {
            scanf("%d %d", &a, &b);
            p1[i] = a, p2[i] = b;
            g[a][b]++, g[b][a]++;
            d[a]++, d[b]++;
        }
        Solve(n);
    }
    return 0;
}

Fucker 2010-05-20 10:40 发表评论

UESTC 1195 Find the Treasure

Fucker — Thu, 20 May 2010 02:36:00 GMT

解法:最大权闭合图,网络流解,也比较裸。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define N 205
#define INF 1 << 29

bool mark[N];
int g[N][N];

int ISAP(int src, int sink, int n)
{
    int maxflow = 0, flow, u = src, v, d;
    int cnt[N], dis[N], pre[N];
    memset(cnt, 0, sizeof(cnt));
    memset(dis, 0, sizeof(dis));
    cnt[0] = n;
    pre[src] = src;
    while(dis[src] < n)
    {
        if(u == sink)
        {
            flow = INF;
            for(int i = sink; i != src; i = pre[i])
            {
                if(g[pre[i]][i] < flow)
                    flow = g[pre[i]][i];
            }
            maxflow += flow;
            u = src;
            for(int i = sink; i != src; i = pre[i])
            {
                g[pre[i]][i] -= flow;
                g[i][pre[i]] += flow;
            }
        }
        for(d = n, v = 0; v < n; v++)
        {
            if(!g[u][v]) continue;
            d = d < dis[v] ? d : dis[v];
            if(dis[v] + 1 == dis[u]) break;
        }
        if(v < n) pre[v] = u, u = v;
        else
        {
            if(!(--cnt[dis[u]])) break;
            ++cnt[dis[u] = d + 1];
            if(u != src) u = pre[u];
        }
    }
    return maxflow;
}

void dfs(int u, int n)
{
    mark[u] = 1;
    for(int i = 0; i < n; i++)
        if(!mark[i] && g[i][u])
            dfs(i, n);
}

int main()
{
    int t, n, m, src, sink, ans1, ans2[N], top;
    int key, treasure;
    scanf("%d", &t);
    while(t--)
    {
        memset(g, 0, sizeof(g));
        memset(ans2, 0, sizeof(ans2));
        memset(mark, 0, sizeof(mark));
        scanf("%d %d", &n, &m);
        src = ans1 = top = 0, sink = n + m + 1;
        for(int i = 1; i <= n; i++)
        {
            scanf("%d", &key);
            g[i + m][sink] = key;
        }
        for(int i = 1; i <= m; i++)
        {
            scanf("%d", &treasure);
            g[src][i] = treasure;
            ans1 += treasure;
        }
        for(int i = 1; i <= m; i++)
        {
            int num, id;
            scanf("%d", &num);
            for(int j = 0; j < num; j++)
            {
                scanf("%d", &id);
                g[i][id + m] = INF;
            }
        }
        ans1 -= ISAP(src, sink, sink + 1);
        printf("%d\n", ans1);
        dfs(sink, sink);
        for(int i = m + 1; i < sink; i++)
        {
            if(!mark[i])
            {
                ans2[top++] = i - m;
            }
        }
        printf("%d", top);
        for(int i = 0; i < top; i++)
        {
            printf(" %d", ans2[i]);
        }
        printf("\n");
    }
    return 0;
}

Fucker 2010-05-20 10:36 发表评论