C++博客-patriking-随笔分类-Algorithm

最小树形图

patriking — Thu, 26 May 2011 05:22:00 GMT

何谓最小树形图，最小树形图，在一个有向图中，定义某个节点为根节点，由该根节点扩展出来的一颗有向的生成树，并且使这棵树的权值最小。练习题POJ3164，

解决该问题的算法有两位中国人提出，有位同学将该论文总结一下：

最小树形图算法(Zhu-Liu Algorithm)：

1. 设最小树形图的总权值为cost，置cost为0。

2. 除源点外，为其他所有节点Vi找一条权值最小的入边，加入集合T。T就是最短边的集合。加边的方法：遍历所有点到Vi的边中权值最小的加入集合T，记pre[Vi]为该边的起点，mincost[Vi]为该边的权值。

3. 检查集合T中的边是否存在有向环，有则转到步骤4，无则转到步骤5。这里需要利用pre数组，枚举检查过的点作为搜索的起点，类似dfs的操作判断有向环。

4. 将有向环缩成一个点。设环中有点{Vk1,Vk2,…,Vki}共i个点，用Vk代替缩成的点。在压缩后的图中，更新所有不在环中的点V到Vk的距离：

map[V][Vk] = min {map[V][Vkj]-mincost[Vki]} 1<=j<=i；

map[Vk][V] = min {map[Vkj][V]} 1<=j<=I。

5. cost加上T中有向边的权值总和就是最小树形图的权值总和。

patriking 2011-05-26 13:22 发表评论

二分图匹配相关的几个概念

patriking — Wed, 23 Feb 2011 01:30:00 GMT

二分图：是这样一个图，它的顶点可以分类两个集合X和Y，所有的边关联在两个顶点中，恰好一个属于集合Ｘ，另一个属于集合Ｙ。
最大匹配：图中包含边数最多的匹配称为图的最大匹配。
完美匹配：如果所有点都在匹配边上，称这个最大匹配是完美匹配。
最小覆盖：最小覆盖要求用最少的点（Ｘ集合或Ｙ集合的都行）让每条边都至少和其中一个点关联。可以证明：最少的点（即覆盖数）＝最大匹配数
最小路径覆盖：用尽量少的不相交简单路径覆盖有向无环图Ｇ的所有结点。解决此类问题可以建立一个二分图模型。把所有顶点i拆成两个：Ｘ结点集中的i和Y结点集中的i',如果有边i->j，则在二分图中引入边i->j'，设二分图最大匹配为m,则结果就是n-m。
最大独立集问题：在Ｎ个点的图G中选出m个点，使这m个点两两之间没有边．求m最大值．如果图Ｇ满足二分图条件，则可以用二分图匹配来做．最大独立集点数 = N - 最大匹配数。

patriking 2011-02-23 09:30 发表评论

ZOJ@3018 二维线段树

patriking — Mon, 24 Jan 2011 06:53:00 GMT

解法:

// 2391826      2011-01-24 14:47:58        Accepted      3018      C++      840      17756      redsea
// 2391828      2011-01-24 14:54:21        Accepted      3018      C++      840      17756      redsea
#include<stdio.h>
#include<string.h>
#define MAXN 500000
#define N 20002
struct seg
{
    int dx, dy, ux, uy;
    int ch[4];
    int total;
}sgt[MAXN];
int sgtn;
int ans;
int w(int x, int y, int dx, int dy, int ux, int uy)
{
    int midx = (dx+ux)/2;
    int midy = (dy+uy)/2;
    if(x>=dx && x<=midx){
        if(y>=dy && y<=midy)
            return 0;
        else
            return 1;
    }
    else
    {
        if(y>=dy && y<=midy)
            return 2;
        else
            return 3;
    }
}
int init(int dx, int ux, int dy, int uy)
{
    sgt[sgtn].dx = dx;
    sgt[sgtn].ux = ux;
    sgt[sgtn].dy = dy;
    sgt[sgtn].uy = uy;
    sgt[sgtn].total = 0;
    for(int i = 0; i < 4; i++)
        sgt[sgtn].ch[i] = -1;
    sgtn++;
    return sgtn-1;
}
void insert(int root, int x, int y, int a)
{
    if(sgt[root].dx == sgt[root].ux && sgt[root].dx == x && sgt[root].dy == sgt[root].uy && sgt[root].dy == y){
        sgt[root].total += a;
        return;
    }
    int id = w(x,y,sgt[root].dx, sgt[root].dy, sgt[root].ux, sgt[root].uy);
    int midx = (sgt[root].dx+sgt[root].ux)/2;
    int midy = (sgt[root].dy+sgt[root].uy)/2;
    sgt[root].total += a;
    if(id == 0){
        if(sgt[root].ch[id] == -1){
            sgt[root].ch[id] = init(sgt[root].dx,midx,sgt[root].dy,midy);
        }
        insert(sgt[root].ch[id],x,y,a);
    }else if(id == 1){
        if(sgt[root].ch[id] == -1){
            sgt[root].ch[id] = init(sgt[root].dx,midx,midy+1,sgt[root].uy);
        }
        insert(sgt[root].ch[id],x,y,a);
    }else if(id == 2){
        if(sgt[root].ch[id] == -1){
            sgt[root].ch[id] = init(midx+1,sgt[root].ux,sgt[root].dy,midy);
        }
        insert(sgt[root].ch[id],x,y,a);
    }else{
        if(sgt[root].ch[id] == -1){
            sgt[root].ch[id] = init(midx+1,sgt[root].ux,midy+1,sgt[root].uy);
        }
        insert(sgt[root].ch[id],x,y,a);
    }
}
void sum(int root, int dx, int dy, int ux, int uy)
{
    if(root < 0)return;
    if(sgt[root].dx > ux || sgt[root].ux < dx || sgt[root].dy > uy || sgt[root].uy < dy)
        return;
    if(sgt[root].dx >= dx && sgt[root].ux <= ux && sgt[root].dy >= dy && sgt[root].uy <= uy)
    {
        ans += sgt[root].total;
        return;
    }else{
        for(int i = 0; i < 4; i++)
        {
            sum(sgt[root].ch[i],dx,dy,ux,uy);
        }
    }
}
int main()
{
    char opes[500];
    char now;
    int x, y, z;
    int x1, x2, y1, y2;
    while(scanf("%s", opes) != EOF){
        now = opes[0];
           getchar();
           sgtn = 1;
        sgt[0].total = 0;
        sgt[0].dx = 1;
        sgt[0].dy = 1;
        sgt[0].ux = 20000;
        sgt[0].uy = 20000;
        for(int i = 0; i < 4; i++)
            sgt[0].ch[i] = -1;
          while(true){
            if(now == 'E') break;
            gets(opes);
            if(opes[0] < '0' || opes[0] > '9'){
                 now = opes[0];
                 continue;
            }
            if(now == 'I'){
                sscanf(opes, "%d %d %d", &x, &y, &z);
                insert(0,x,y,z);
            }else{
                 sscanf(opes, "%d %d %d %d", &x1, &x2 , &y1, &y2);
                 ans = 0;
                 sum(0,x1,y1,x2,y2);
                printf("%d\n", ans);
            }
        }
       }
       return 0;
}

二维线段树。

patriking 2011-01-24 14:53 发表评论

混合图欧拉路(判断)

patriking — Mon, 24 Jan 2011 02:51:00 GMT

问题：对于一个混合图，即有有向边又有无向边的图，判断是否存在一条欧拉回路。
解法（转）：混合图欧拉回路用的是网络流。把该图的无向边随便定向，计算每个点的入度和出度。如果有某个点出入度之差为奇数，那么肯定不存在欧拉回路。因为欧拉回路要求每点入度 = 出度，也就是总度数为偶数，存在奇数度点必不能有欧拉回路。现在每个点入度和出度之差均为偶数。将这个偶数除以2，得x。即是说，对于每一个点，只要将x条边反向（入>出就是变入，出>入就是变出），就能保证出 = 入。如果每个点都是出 = 入，那么很明显，该图就存在欧拉回路。现在的问题就变成了：该改变哪些边，可以让每个点出 = 入？构造网络流模型。有向边不能改变方向，直接删掉。开始已定向的无向边，定的是什么向，就把网络构建成什么样，边长容量上限1。另新建s和t。对于入 > 出的点u，连接边(u, t)、容量为x，对于出 > 入的点v，连接边(s, v)，容量为x（注意对不同的点x不同。当初由于不小心，在这里错了好几次）。之后，察看是否有满流的分配。有就是能有欧拉回路，没有就是没有。查看流值分配，将所有流量非 0（上限是1，流值不是0就是1）的边反向，就能得到每点入度 = 出度的欧拉图。由于是满流，所以每个入 > 出的点，都有x条边进来，将这些进来的边反向，OK，入 = 出了。对于出 > 入的点亦然。那么，没和s、t连接的点怎么办？和s连接的条件是出 > 入，和t连接的条件是入 > 出，那么这个既没和s也没和t连接的点，自然早在开始就已经满足入 = 出了。那么在网络流过程中，这些点属于“中间点”。我们知道中间点流量不允许有累积的，这样，进去多少就出来多少，反向之后，自然仍保持平衡。所以，就这样，混合图欧拉回路问题，解了。
ZOJ@1992

// 2391682      2011-01-24 10:49:56        Accepted      1992      C++      90      508      redsea
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<string.h>
using namespace std;
#define N 205
#define MAXN N
#define inf 100000000
int map[N][N];
int flow[N][N];
int max_flow(int n,int mat[][MAXN],int source,int sink,int flow[][MAXN]){
    int pre[MAXN],que[MAXN],d[MAXN],p,q,t,i,j;
    if (source==sink) return inf;
    for (i=0;i<n;i++)
        for (j=0;j<n;flow[i][j++]=0);
    for (;;){
        for (i=0;i<n;pre[i++]=0);
        pre[t=source]=source+1,d[t]=inf;
        for (p=q=0;p<=q&&!pre[sink];t=que[p++])
               for (i=0;i<n;i++)
                if (!pre[i]&&(j=mat[t][i]-flow[t][i]))
                     pre[que[q++]=i]=t+1,d[i]=d[t]<j?d[t]:j;
                else if (!pre[i]&&(j=flow[i][t]))
                 pre[que[q++]=i]=-t-1,d[i]=d[t]<j?d[t]:j;
        if (!pre[sink]) break;
        for (i=sink;i!=source;)
               if (pre[i]>0)
                flow[pre[i]-1][i]+=d[sink],i=pre[i]-1;
               else
                flow[i][-pre[i]-1]-=d[sink],i=-pre[i]-1;
    }
    for (i=0;i<n;i++)
        if(mat[source][i] > flow[source][i])
            return 0;
    return 1;
}
int main()
{
    int T, degin[N],degout[N], n, m, x, y, z;
    int flag;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        memset(degin,0,sizeof(degin));
        memset(degout,0,sizeof(degout));
        memset(map,0,sizeof(map));
        for(int i = 0; i < m; i++){
            scanf("%d%d%d",&x,&y,&z);
            degout[x]++;
            degin[y]++;
            if(!z)map[x][y]++;
        }
        flag = 0;
        for(int i = 1; i <= n && !flag; i++){
            if((degin[i]+degout[i])%2)flag=1;
            if(degin[i] > degout[i])
                map[i][n+1] = (degin[i]-degout[i])/2;
            else
                map[0][i] = (degout[i]-degin[i])/2;
        }
        if(flag)
            printf("impossible\n");
        else{
            if(max_flow(n+2,map,0,n+1,flow))
                printf("possible\n");
            else
                printf("impossible\n");
        }
    }
    return 0;
}

patriking 2011-01-24 10:51 发表评论

ZOJ@2616

patriking — Fri, 21 Jan 2011 09:21:00 GMT

ZOJ@2616
题意：政府拍卖n个无线频道，两公司竞争，分别提出一些组合的竞标，每个标单需要多个无线频道，同一家公司提出标单之间不没有共同的频道，两个公司的标单可能竞争同一个频道。求政府最大收益？
解法：二分图，两边分别两公司的标单，有竞争的标单之间连边，容量为无穷大。添加一个汇点，连第一家公司的标单，容量为标单价格；同理添加一个汇...。所求结果为所有标单总价值-最大流。

// 2390064      2011-01-21 10:19:41        Accepted      2616      C++      4790      4256      redsea
//  Dinic最大流 O(V^2 * E)
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;
#define N 6002
#define E N*33
#define typec int                   // type of cost
const typec inf = 30000000;       // max of cost
struct edge {
    int x, y, nxt; typec c;
}bf[E];
int ne, head[N], cur[N], ps[N], dep[N];

vector<int>v1[3001];
vector<int>v2[3001];
int value1[3001], value2[3001];

void addedge(int x, int y, typec c)
{
    // add an arc(x -> y, c); vertex: 0 ~ n-1;
      bf[ne].x = x; bf[ne].y = y; bf[ne].c = c;
      bf[ne].nxt = head[x]; head[x] = ne++;
      bf[ne].x = y; bf[ne].y = x; bf[ne].c = 0;
      bf[ne].nxt = head[y]; head[y] = ne++;
}
typec flow(int n, int s, int t)
{
      typec tr, res = 0;
    int i, j, k, f, r, top;
    while (1) {
        memset(dep, -1, n * sizeof(int));
           for (f = dep[ps[0] = s] = 0, r = 1; f != r; )
            for (i = ps[f++], j = head[i]; j; j = bf[j].nxt)
            {
                 if (bf[j].c && -1 == dep[k = bf[j].y]){
                      dep[k] = dep[i] + 1; ps[r++] = k;
                      if (k == t) { f = r; break; }
                }
               }
            if (-1 == dep[t]) break;
            memcpy(cur, head, n * sizeof(int));
            for (i = s, top = 0; ; ) {
                if (i == t) {
                    for (k = 0, tr = inf; k < top; ++k)
                         if (bf[ps[k]].c < tr)
                            tr = bf[ps[f = k]].c;
                    for (k = 0; k < top; ++k)
                        bf[ps[k]].c -= tr, bf[ps[k]^1].c += tr;
                       res += tr;  i = bf[ps[top = f]].x;
                }
            for  (j=cur[i]; cur[i]; j = cur[i] = bf[cur[i]].nxt)
                if  (bf[j].c && dep[i]+1 == dep[bf[j].y])break;
            if (cur[i]) {
                ps[top++] = cur[i];
                i = bf[cur[i]].y;
            }
            else {
                 if (0 == top) break;
                dep[i] = -1; i = bf[ps[--top]].x;
            }
        }
    }
    return res;
}

bool check(int x, int y)
{
    int i = 0, j = 0;
    while(i<v1[x].size()&&j<v2[y].size())
    {
        if(v1[x][i] < v2[y][j])
            i++;
        else if(v1[x][i] > v2[y][j])
            j++;
        else
            return true;
    }
    return false;
}

int main()
{
    int T, x, nbuf, n, m, value;
    scanf("%d",&T);
    char buf[1000];
    char *p;
    int tcase = 0;
    while(T--)
    {
        scanf("%d",&n);
        for(int i = 1; i <= n; i++){
            v1[i].clear();
            scanf("%d",&value1[i]);
            scanf("%[^\n]",buf);
            p = buf;
            while(sscanf(p,"%*[^-0-9]%d%n",&value,&x)>0)
            {
                p += x;
                v1[i].push_back(value);
            }
            sort(v1[i].begin(),v1[i].end());
        }
        scanf("%d",&m);
        for(int i = 1; i <= m; i++){
            v2[i].clear();
            scanf("%d",&value2[i]);
            scanf("%[^\n]",buf);
            p = buf;
            while(sscanf(p,"%*[^0-9]%d%n",&value,&x)>0)
            {
                p += x;
                v2[i].push_back(value);
            }
            sort(v2[i].begin(),v2[i].end());
        }
        memset(head,0,sizeof(head));
        ne = 2;
        int total = 0;
        for(int i = 1; i <= n; i++){
            total += value1[i];
            addedge(0, i, value1[i]);
        }
        for(int i = 1; i <= m; i++){
            total += value2[i];
            addedge(n+i,n+m+1,value2[i]);
        }
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                if(check(i,j)){
                    addedge(i,j+n,inf);
                }
            }
        }
        printf("Case %d:\n%d\n",++tcase,total-flow(n+m+2,0,n+m+1));
        if(T)
            printf("\n");
    }
    return 0;
}

patriking 2011-01-21 17:21 发表评论

判断最小割是否唯一 ZOJ@2587

patriking — Fri, 21 Jan 2011 09:11:00 GMT

ZOJ@2587
题意：判断最小割是否唯一。
思路（转）：判断最小割是否唯一，先求一次最大流，然后在残留网络中分别从源汇开始dfs一次，找出最小割[S,T]，如果SUT不包含所有点，那么最小割不唯一。假设点i不被SUT包含，那么残留网络中s不能到达i,i不能到达t,即进入i的边和从i出去的边都满流，假设某条进入i的边x满流，这些流量从若干条边y流出i，那么，如果选x为割边，或者选所有对应的y为割边，不会影响最大流，即最小割容量不变，最小割也就不唯一。

// 2390377      2011-01-21 16:52:22        Accepted      2587      C++      150      3324      redsea
//  Dinic最大流 O(V^2 * E)
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
#define N 802
#define E 200050
#define typec int                   // type of cost
const typec inf = 30000000;       // max of cost
struct edge {
    int x, y, nxt; typec c;
}bf[E];
int ne, head[N], cur[N], ps[N], dep[N];

void addedge(int x, int y, typec c)
{
    // add an arc(x -> y, c); vertex: 0 ~ n-1;
      bf[ne].x = x; bf[ne].y = y; bf[ne].c = c;
      bf[ne].nxt = head[x]; head[x] = ne++;
      bf[ne].x = y; bf[ne].y = x; bf[ne].c = 0;
      bf[ne].nxt = head[y]; head[y] = ne++;
}
typec flow(int n, int s, int t)
{
      typec tr, res = 0;
    int i, j, k, f, r, top;
    while (1) {
        memset(dep, -1, n * sizeof(int));
           for (f = dep[ps[0] = s] = 0, r = 1; f != r; )
            for (i = ps[f++], j = head[i]; j; j = bf[j].nxt)
            {
                 if (bf[j].c && -1 == dep[k = bf[j].y]){
                      dep[k] = dep[i] + 1; ps[r++] = k;
                      if (k == t) { f = r; break; }
                }
               }
        if (-1 == dep[t]) break;
        memcpy(cur, head, n * sizeof(int));
        for (i = s, top = 0; ; ) {
            if (i == t) {
                for (k = 0, tr = inf; k < top; ++k)
                     if (bf[ps[k]].c < tr)
                        tr = bf[ps[f = k]].c;
                for (k = 0; k < top; ++k)
                    bf[ps[k]].c -= tr, bf[ps[k]^1].c += tr;
                   res += tr;  i = bf[ps[top = f]].x;
            }
            for  (j=cur[i]; cur[i]; j = cur[i] = bf[cur[i]].nxt)
                   if  (bf[j].c && dep[i]+1 == dep[bf[j].y])break;
            if (cur[i]) {
                   ps[top++] = cur[i];
                   i = bf[cur[i]].y;
               }
               else {
                 if (0 == top) break;
                   dep[i] = -1; i = bf[ps[--top]].x;
               }
           }
    }
    return res;
}
int cnts, cntt;
int flag1[N], flag2[N];

void dfs1(int v)
{
    flag1[v] = 1;
    cnts++;
    for(int i = head[v]; i != 0; i = bf[i].nxt){
        if(flag1[bf[i].y]==0 && bf[i].c)
            dfs1(bf[i].y);
    }
}
void dfs2(int v)
{
    flag2[v] = 1;
    cntt++;
    for(int i = head[v]; i != 0; i = bf[i].nxt){
        if(flag2[bf[i].y]==0 && bf[i^1].c)
            dfs2(bf[i].y);
    }
}
int main()
{
    int n, m, s, t, x, y, c;
    while(scanf("%d%d%d%d",&n,&m,&s,&t), n||m||s||t)
    {
        memset(head,0,sizeof(head));
        ne = 2;
        for(int i = 0; i < m; i++){
            scanf("%d%d%d",&x,&y,&c);
            x--,y--;
            addedge(x,y,c);
            addedge(y,x,c);
        }
        s--;t--;
        flow(n,s,t);
        memset(flag1,0,sizeof(flag1));
        memset(flag2,0,sizeof(flag2));
        cnts = cntt = 0;
        dfs1(s);
        dfs2(t);
        if(cnts+cntt!=n)
            printf("AMBIGUOUS\n");
        else printf("UNIQUE\n");
    }
    return 0;
}

patriking 2011-01-21 17:11 发表评论

最小割 ZOJ@2788

patriking — Thu, 20 Jan 2011 07:52:00 GMT

    最大流最小割定理介绍：把一个流网络的顶点集划分成两个集合S和T，使得源点s ∈S且汇点t ∈T，割(S,T)的容量C(S,T) = ∑ Cuv, 其中u∈S且v∈T。
从直观上看，截集(S,T)是从源点s到汇点t的必经之路，如果该路堵塞则流从s无法到达t。于是我们可以得到最大流最小割定理：任意一个流网络的最大流量等于该网络的最小的割的容量。
    最小割问题：ZOJ@2788
    题意：在一栋楼中有若干房间，一个房间有若干扇门通往别的房间，现在房间中有一个secure room。由于有一些敌人已经潜入某一些房间，现在问关闭最少的一些门，使得敌人们到达不了secure room。对于一扇门连通A-B，若控制面板CP在A方，则总是可以从A->B，但是若关上门，则B不能到达A。
    解法：最大流。首先通过floyd算法判断是否敌人总是可以到达secure room，如果能直接输出结果；如果不能，则通过最大流算法求解即可。对于一扇门A-B，CP在A方则从A连一条有向边到B，容量为无穷大，从B连一条边到A，容量为1。两个房间之间可能有多扇门，边的容量累加即可。增加一个源点，从源点连边到有敌人的房间，容量为1。对图求最大流即为结果。
代码如下：

// 2389732      2011-01-20 15:06:16        Accepted      2788      C++      0      184      *******
#include<cstdio>
#include<algorithm>
#include<cstring>
#define MAXN 22
#define inf 1000000
int map[MAXN][MAXN];
int flow[MAXN][MAXN];
int max_flow(int n,int mat[][MAXN],int source,int sink,int flow[][MAXN]){
    int pre[MAXN],que[MAXN],p,q,t,i,j;
    int d[MAXN];
    int tmp;
    if (source==sink) return inf;
    for (i=0;i<n;i++)
        for    (j=0;j<n;flow[i][j++]=0);
    for (;;){
        for (i=0;i<n;pre[i++]=0);
        pre[t=source]=source+1,d[t]=inf;
        for (p=q=0;p<=q&&!pre[sink];t=que[p++])
               for (i=0;i<n;i++)
                if (!pre[i]&&(tmp=mat[t][i]-flow[t][i]))
                     pre[que[q++]=i]=t+1,d[i]=d[t]<tmp?d[t]:tmp;
                else if (!pre[i]&&(tmp=flow[i][t]))
                 pre[que[q++]=i]=-t-1,d[i]=d[t]<tmp?d[t]:tmp;
        if (!pre[sink]) break;
        for (i=sink;i!=source;)
               if (pre[i]>0)
                flow[pre[i]-1][i]+=d[sink],i=pre[i]-1;
               else
                flow[i][-pre[i]-1]-=d[sink],i=-pre[i]-1;
    }
    tmp = 0;
    for (i=0;i<n;tmp+=flow[source][i++]);
    return tmp;
}
int main()
{
    int T, n, m, k, y;
    char str[3];
    int d[MAXN];
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&m,&n);
        n++;
        memset(map,0,sizeof(map));
        memset(flow,0,sizeof(flow));
        for(int i = 1; i <= m; i++){
            scanf("%s %d",str, &k);
            d[i] = (strlen(str) == 1);
            if(d[i])map[0][i] = inf;
            for(int j = 0; j < k; j++){
                scanf("%d",&y);
                y++;
                flow[i][y] = 1;
                map[i][y] += inf;
                map[y][i] += 1;
            }
        }
        // Checking always exists a path to secure room. Output "PANIC ROOM BREACH"!
        for(k = 1; k <= m; k++)
            for(int i = 1; i <= m; i++)
                for(int j = 1; j <= m; j++)
                    if(flow[i][k]&&flow[k][j])
                        flow[i][j] = 1;
        for(k = 1; k <= m && !(d[k] && flow[k][n]); k++);
        if(k <= m)
            printf("PANIC ROOM BREACH\n");
        else
            printf("%d\n", max_flow(m+1,map,0,n,flow));
    }
    return 0;
}

patriking 2011-01-20 15:52 发表评论

ZOJ@2874-Paratroopers

patriking — Wed, 19 Jan 2011 12:35:00 GMT

ZOJ@2874
题意：给一个n*m的网格，网格中某些位有敌人，现在可以在网格边上的x轴或者y轴设置炮台，x炮台可以消灭所在列上的所有敌人，y炮台可以消灭所在行上的所有敌人。现在给定修建x炮台,y炮台的费用，问如何设置炮台，使得消灭所有敌人总费用最少（总费用为设置炮台费用之积）。
解法：最大流。首先对炮台费用求对数，使得总费用之积转化为之和。建图：从源点连有向边到x轴，边的容量为在该处设置炮台的费用；y轴上的点连有向边到汇点，边容量为在该点设置炮台的费用；如果网格中点(x,y)处有敌人，则从x处连边到y，边的容量设置为无穷大。

Code

// 2389416      2011-01-19 19:57:39        Accepted      2874      C++      40      352      redsea
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cmath>
using namespace std;
#define MAXN 105
#define inf 1000000000.00
double map[MAXN][MAXN];
double flow[MAXN][MAXN];
double max_flow(int n,double mat[][MAXN],int source,int sink,double flow[][MAXN]){
    int pre[MAXN],que[MAXN],p,q,t,i,j;
    double d[MAXN];
    double tmp;
    if (source==sink) return inf;
    for (i=0;i<n;i++)
        for (j=0;j<n;flow[i][j++]=0);
    for (;;){
        for (i=0;i<n;pre[i++]=0);
        pre[t=source]=source+1,d[t]=inf;
        for (p=q=0;p<=q&&!pre[sink];t=que[p++])
               for (i=0;i<n;i++)
                if (!pre[i]&&(tmp=mat[t][i]-flow[t][i]))
                     pre[que[q++]=i]=t+1,d[i]=d[t]<tmp?d[t]:tmp;
                else if (!pre[i]&&(tmp=flow[i][t]))
                 pre[que[q++]=i]=-t-1,d[i]=d[t]<tmp?d[t]:tmp;
        if (!pre[sink]) break;
        for (i=sink;i!=source;)
               if (pre[i]>0)
                flow[pre[i]-1][i]+=d[sink],i=pre[i]-1;
               else
                flow[i][-pre[i]-1]-=d[sink],i=-pre[i]-1;
    }
    tmp = 0;
    for (i=0;i<n;tmp+=flow[source][i++]);
    return tmp;
}
int main()
{
    int T, n, m, l, s, t;
    double x;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d%d",&m,&n,&l);
        s = 0;
        t = m+n+1;
        for(int i = 0; i < n+m+2; i++)
            for(int j = 0; j < n+m+2; j++)
                map[i][j] = 0;
        for(int i = 1; i <= m; i++){
            scanf("%lf",&x);
            map[s][i] = log10(x);
        }
        for(int i = m+1; i <= n+m; i++){
            scanf("%lf",&x);
            map[i][t] = log10(x);
        }
        for(int i = 0; i < l; i++){
            int sx, sy;
            scanf("%d%d",&sx,&sy);
            map[sx][m+sy] = 10;
        }
        printf("%.4lf\n", pow(10.0, max_flow(n+m+2,map,s,t,flow)));
    }
    return 0;
}

patriking 2011-01-19 20:35 发表评论

STL之Set operation on sorted structures

patriking — Tue, 18 Jan 2011 02:17:00 GMT

Set operations on sorted structures 为STL中对两个有序序列的操作，包括包含、合并、求交集、求差、求对称差。
包含：如果[first2,last2)包含在[first1,last1)中，返回true,否则返回false。
bool includes(InputIterator1 first1, InputIterator1 last1,InputIterator2 first2, InputIterator2 last2)
bool includes(InputIterator1 first1, InputIterator1 last1,InputIterator2 first2, InputIterator2 last2, Compare comp)

合并：合并[first1,last1)与[first2,last2)两个集合。
OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)

求交集：求[first1,last1)与[first2,last2)两个集合的交集。
OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)

求差：求在[first1,last1)中，而不在[first2,last2)的元素集合。
OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)

求对称差：两个集合之和集减去两个集合之交集。
OutputIterator set_symmetric difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
OutputIterator set_symmetric difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)

#include<iostream>
#include<algorithm>
#include<vector>
#include<iterator>
using namespace std;
void init(vector<int>& v, int a, int b)
{
    v.clear();
    for(int i = a; i <= b; i++){
        v.push_back(i);
    }
}
int main()
{
    vector<int>v1, v2;
    vector<int>::iterator itr;
    cout << "Includes operator:" << endl;
    init(v1,1,5);
    init(v2,1,8);
    cout << "Vector v1: ";
    copy(v1.begin(),v1.end(),ostream_iterator<int>(cout," "));
    cout << endl;
    cout << "Vector v2: ";
    copy(v2.begin(),v2.end(),ostream_iterator<int>(cout," "));
    cout << endl;
    cout << "v2 is in v1 ? " << (includes(v1.begin(),v1.end(),v2.begin(),v2.end()) ? "yes" : "no") << endl;
    cout << "v1 is in v2 ? " << (includes(v2.begin(),v2.end(),v1.begin(),v1.end()) ? "yes" : "no") << endl;

    cout << endl;
    init(v1,1,5);
    init(v2,3,8);
    cout << "Vector v1: ";
    copy(v1.begin(),v1.end(),ostream_iterator<int>(cout," "));
    cout << endl;
    cout << "Vector v2: ";
    copy(v2.begin(),v2.end(),ostream_iterator<int>(cout," "));
    cout << endl;
    cout << "set_union operator on v1,v2: ";
    set_union(v1.begin(),v1.end(),v2.begin(),v2.end(),ostream_iterator<int>(cout," "));
    cout << endl << endl;

    init(v1,1,5);
    init(v2,3,8);
    cout << "Vector v1: ";
    copy(v1.begin(),v1.end(),ostream_iterator<int>(cout," "));
    cout << endl;
    cout << "Vector v2: ";
    copy(v2.begin(),v2.end(),ostream_iterator<int>(cout," "));
    cout << endl;
    cout << "set_intersecion operator on v1,v2: ";
    set_intersection(v1.begin(),v1.end(),v2.begin(),v2.end(),ostream_iterator<int>(cout," "));
    cout << endl << endl;

    init(v1,1,5);
    init(v2,3,8);
    cout << "Vector v1: ";
    copy(v1.begin(),v1.end(),ostream_iterator<int>(cout," "));
    cout << endl;
    cout << "Vector v2: ";
    copy(v2.begin(),v2.end(),ostream_iterator<int>(cout," "));
    cout << endl;
    cout << "set_difference operator, v1 to v2: ";
    set_difference(v1.begin(),v1.end(),v2.begin(),v2.end(),ostream_iterator<int>(cout," "));
    cout << endl;
    cout << "set_difference operator, v2 to v1: ";
    set_difference(v2.begin(),v2.end(),v1.begin(),v1.end(),ostream_iterator<int>(cout," "));
    cout << endl << endl;

    init(v1,1,5);
    init(v2,3,8);
    cout << "Vector v1: ";
    copy(v1.begin(),v1.end(),ostream_iterator<int>(cout," "));
    cout << endl;
    cout << "Vector v2: ";
    copy(v2.begin(),v2.end(),ostream_iterator<int>(cout," "));
    cout << endl;
    cout << "set_symmetric_difference operator, v1 to v2: ";
    set_symmetric_difference(v1.begin(),v1.end(),v2.begin(),v2.end(),ostream_iterator<int>(cout," "));
    cout << endl;
    cout << "set_symmetric_difference operator, v2 to v1: ";
    set_symmetric_difference(v2.begin(),v2.end(),v1.begin(),v1.end(),ostream_iterator<int>(cout," "));
    cout << endl << endl;
    return 0;
}

Includes operator:
Vector v1: 1 2 3 4 5
Vector v2: 1 2 3 4 5 6 7 8
v2 is in v1 ? no
v1 is in v2 ? yes

Vector v1: 1 2 3 4 5
Vector v2: 3 4 5 6 7 8
set_union operator on v1,v2: 1 2 3 4 5 6 7 8

Vector v1: 1 2 3 4 5
Vector v2: 3 4 5 6 7 8
set_intersecion operator on v1,v2: 3 4 5

Vector v1: 1 2 3 4 5
Vector v2: 3 4 5 6 7 8
set_difference operator, v1 to v2: 1 2
set_difference operator, v2 to v1: 6 7 8

Vector v1: 1 2 3 4 5
Vector v2: 3 4 5 6 7 8
set_symmetric_difference operator, v1 to v2: 1 2 6 7 8
set_symmetric_difference operator, v2 to v1: 1 2 6 7 8

patriking 2011-01-18 10:17 发表评论

STL之Merge

patriking — Mon, 17 Jan 2011 13:35:00 GMT

STL中合并算法merge介绍，merge与inplace_merge。
merge合并两个有序的sequence，默认为<比较，可自定义比较函数comp，结果保存在[result, result + (last1 - first1) + (last2 - first2)) 中。函数定义如下：
OutputIterator merge (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
OutputIterator merge (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)

inplace_merge合并一个中前后两段分别有序的序列，即[first,middle)与[middle,last)分别有序，合并这两个子序列，并把结果保存在[first,last）中。
inplace_merge (BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last);
inplace_merge (BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp);

#include<string>
#include<algorithm>
#include<iostream>
#include<iterator>
#include<vector>
using namespace std;
int main()
{
    vector<int>v1;
    vector<int>v2;
    vector<int>v3;
    vector<int>::iterator vecitr;
    for(int i = 1; i <= 10; i++){
        v1.push_back(i%7);
        v2.push_back(i%4);
    }
    sort(v1.begin(),v1.end());
    cout << "Fisrt vecter: ";
    copy(v1.begin(),v1.end(),ostream_iterator<int>(cout," "));
    cout << endl << endl;
    sort(v2.begin(),v2.end());
    cout << "Second vecter: ";
    copy(v2.begin(),v2.end(),ostream_iterator<int>(cout," "));
    cout << endl << endl;
    cout << "Merge this two vecter: ";
    merge(v1.begin(),v1.end(),v2.begin(),v2.end(),ostream_iterator<int>(cout," "));
    cout << endl << endl;
    for(int i = 1; i <= 10; i++){
        v3.push_back(i%7);
    }
    sort(v3.begin(),v3.end());
    int x = v3.size();
    for(int i = 1; i <= 10; i++){
        v3.push_back(i%4);
    }
    vecitr = v3.begin();
    advance(vecitr,x);
    sort(vecitr,v3.end());
    cout << "Third vecter: ";
    copy(v3.begin(),v3.end(),ostream_iterator<int>(cout," "));
    cout << endl << endl;
    cout << "inplace_Merge third vecter: ";
    inplace_merge(v3.begin(),vecitr,v3.end());
    copy(v3.begin(),v3.end(),ostream_iterator<int>(cout," "));
    cout << endl << endl;
    return 0;
}

Fisrt vecter: 0 1 1 2 2 3 3 4 5 6

Second vecter: 0 0 1 1 1 2 2 2 3 3

Merge this two vecter: 0 0 0 1 1 1 1 1 2 2 2 2 2 3 3 3 3 4 5 6

Third vecter: 0 1 1 2 2 3 3 4 5 6 0 0 1 1 1 2 2 2 3 3

inplace_Merge third vecter: 0 0 0 1 1 1 1 1 2 2 2 2 2 3 3 3 3 4 5 6

patriking 2011-01-17 21:35 发表评论

STL之Binary search

patriking — Sun, 16 Jan 2011 14:40:00 GMT

STL中对于有序序列（vector,list等）提供了相当相当强大的二分搜索Binary search算法。对于可以随机访问容器（如vector等），binary search负载度为对数级别（LogN)，对于非随机访问容器（如list），则算法复杂度为线性。现在简要介绍一下几种常用的binary search算法：

ForwardIterator lower_bound (ForwardIterator first,ForwardIterator last, const T& value)
ForwardIterator lower_bound (ForwardIterator first,ForwardIterator last, const T& value, Compare comp)
//查找最远的一个iterator i，使得[first,i)里面的任意一个iterator j，有 *j < value or comp(*j,value)==true.

ForwardIterator upper_bound (ForwardIterator first,ForwardIterator last, const T& value)
ForwardIterator upper_bound (ForwardIterator first,ForwardIterator last, const T& value, Compare comp)
//查找最远的一个iterator i，使得[first,i)里面的任意一个iterator j，有 !(*j < value) or comp(*j,value)==false.

pair equal_range(ForwardIterator first, ForwardIterator last, const T& value)
pair equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp)
//查找最大的subrange[i,j)，使得任意一个iterator in [i,j)满足!(*k
bool binary_search (ForwardIterator first, ForwardIterator last, const T& value)
bool binary_search (ForwardIterator first, ForwardIterator last, const T& value, Compare comp)
// 查找是否在[first,last)中存在iterator i,满足 !(*i// 存在则返回true,否则返回false.

#include<algorithm>
#include<iostream>
#include<vector>
#include<iterator>
using namespace std;
int main()
{
    vector<int>v;
    vector<int>::iterator itr;
    pair< vector<int>::iterator, vector<int>::iterator >vecpair;

    for(int i = 1; i <= 20; i++){
        v.push_back(i%6);
    }
    sort(v.begin(),v.end());
    cout << "array: " << endl << "    ";
    copy(v.begin(),v.end(),ostream_iterator<int>(cout," "));
    cout << endl;

    //lower_bound
    cout << "lower_bound function, value = 3:" << endl;
    itr = lower_bound(v.begin(),v.end(),3);
    cout << "    [first, itr) = ";
    copy(v.begin(),itr,ostream_iterator<int>(cout," "));
    cout << endl;
    cout << "    [itr, last) = ";
    copy(itr,v.end(),ostream_iterator<int>(cout," "));
    cout << endl << endl;

    // upper_bound
    cout << "upper_bound function, value = 3:" << endl;
    itr = upper_bound(v.begin(),v.end(),3);
    cout << "    [first, itr) = ";
    copy(v.begin(),itr,ostream_iterator<int>(cout," "));
    cout << endl;
    cout << "    [itr, last) = ";
    copy(itr,v.end(),ostream_iterator<int>(cout," "));
    cout << endl << endl;

    // equal_range
    cout << "equal_range function, value = 3:" << endl;
    vecpair = equal_range(v.begin(),v.end(),3);

    cout << "    [vecpair->first, vecpair->second) = ";
    copy(vecpair.first, vecpair.second, ostream_iterator<int>(cout," "));
    cout << endl << endl;

    //binary_search, value = 3
    cout << "binary_search function, value = 3:" << endl;
    cout << "3 is " << (binary_search(v.begin(),v.end(),3) ? "":"not ") << "in array." << endl;
    cout << endl;

    //binary_search, value = 6
    cout << "binary_search function, value = 6:" << endl;
    cout << "6 is " << (binary_search(v.begin(),v.end(),6) ? "":"not ") << "in array." << endl;
    cout << endl;

    return 0;
}

array:
    0 0 0 1 1 1 1 2 2 2 2 3 3 3 4 4 4 5 5 5
lower_bound function, value = 3:
    [first, itr) = 0 0 0 1 1 1 1 2 2 2 2
    [itr, last) = 3 3 3 4 4 4 5 5 5

upper_bound function, value = 3:
    [first, itr) = 0 0 0 1 1 1 1 2 2 2 2 3 3 3
    [itr, last) = 4 4 4 5 5 5

equal_range function, value = 3:
    [vecpair->first, vecpair->second) = 3 3 3

binary_search function, value = 3:
3 is in array.

binary_search function, value = 6:
6 is not in array.

patriking 2011-01-16 22:40 发表评论

ZOJ@3433

patriking — Sat, 15 Jan 2011 13:44:00 GMT

ZOJ@3433
题意：m个按序迷宫，每个迷宫可收集一定数量的cake，迷宫中的BOSS有n个ice heart，每一个需消耗的一定cake才能获得，问通过这m个迷宫，可拿多少ice heart。
解法：贪心。对于一个ice heart，如果当前cake数大于或等于该ice heart的消耗，则直接取得，如果不，则用前面消耗的最大cake的与当前ice heart比较，当前ice heart消耗小些，则交换，赚一点cake，否则不换。用一个最大堆维护即可。

// 2386805      2011-01-15 21:33:57        Accepted      3433      C++      350      4100      redsea
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include<queue>
using namespace std;
struct laby
{
    int n;
    int cake;
    int sp[1001];
}l[1001];
int m;
struct Node
{
    int cake;
    bool operator < (struct Node a)const
    {
        return cake < a.cake;
    }
};
void solve()
{
    priority_queue<struct Node>Heap;
    struct Node tmp;
    int cake = 0;
    int ans = 0;
    for(int i = 1; i <= m; i++)
    {
        cake += l[i].cake;
        for(int j = 0; j < l[i].n; j++)
        {
            if(cake >= l[i].sp[j])
            {
                ans++;
                cake -= l[i].sp[j];
                tmp.cake = l[i].sp[j];
                Heap.push(tmp);
            }else{
                if(!Heap.empty())
                {
                    tmp = Heap.top();
                    if(tmp.cake > l[i].sp[j]){
                        cake += tmp.cake;
                        ans--;
                        Heap.pop();
                    }
                }
                if(cake >= l[i].sp[j])
                {
                    ans++;
                    cake -= l[i].sp[j];
                    tmp.cake = l[i].sp[j];
                    Heap.push(tmp);
                }
            }
        }
    }
    printf("%d\n",ans);
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&m);
        for(int i = 1; i <= m; i++){
            scanf("%d",&l[i].n);
            for(int j = 0; j < l[i].n; j++){
                scanf("%d",&l[i].sp[j]);
            }
        }
        for(int i = 1; i <= m; i++)
        {
            scanf("%d",&l[i].cake);
        }
        solve();
    }
    return 0;
}

patriking 2011-01-15 21:44 发表评论

ZOJ@3431

patriking — Sat, 15 Jan 2011 08:42:00 GMT

ZOJ@3431
题意：有一n层的城堡，每一层有通往下一层的楼梯。对于第i层，通往下层的楼梯在Xi,Yi处；该层有Mi个宝藏，分别给出其坐标和价值；必须在Ti时刻之前（包括）离开，否则楼梯关闭。开始处在第顶层的X,Y处，且每一个单位时刻内可以走一个单位的距离，只能往上下左右四个方向走，通过楼梯不费时间。问能否在规定时间内离开城堡，如果可以的话输出能获得的最大宝藏价值。
解法：动态规划（DP)。

// 2386571      2011-01-15 16:32:37        Accepted      3431      C++      130      416      redsea
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<string.h>
using namespace std;
struct Floor{
    int m;
    int x[8], y[8], value[8];
    int t[257],v[257];
}p[105];
int st[105];

int f[2][1205];

inline int abs(int a)
{
    return (a>0?a:-a);
}
int main()
{
    int T;
    int x, y, n;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        scanf("%d%d",&x,&y);
        p[0].x[0] = x;
        p[0].y[0] = y;
        scanf("%d%d",&x,&y);
        p[0].x[1] = x;
        p[0].y[1] = y;
        for(int i = 1; i < n; i++)
        {
            p[i].x[0] = p[i-1].x[1];
            p[i].y[0] = p[i-1].y[1];
            scanf("%d%d",&x,&y);
            p[i].x[1] = x;
            p[i].y[1] = y;
        }
        for(int i = 0; i < n; i++){
            p[i].value[0] = p[i].value[1] = 0;
            scanf("%d",&p[i].m);
            for(int j = 0; j < p[i].m; j++){
                scanf("%d%d%d",&p[i].x[2+j], &p[i].y[2+j], &p[i].value[2+j]);
            }
        }
        for(int i = 0; i < n; i++){
            scanf("%d", &st[i]);
        }
        for(int i = 0; i < n; i++)
            for(int j = 0; j < 256; j++){
                p[i].t[j] = -1;
                p[i].v[j] = -1;
            }
        for(int i = 0; i < n; i++)
        {
            int a[6], b[9];
            for(int j = 0; j < p[i].m; j++){
                a[j] = j+2;
            }
            p[i].t[3] = abs(p[i].x[0]-p[i].x[1]) + abs(p[i].y[0]-p[i].y[1]);
            p[i].v[3] = 0;
            b[0] = 0;
            do{
                for(int j = 0; j < p[i].m; j++)
                {
                    b[j+1] = a[j];
                    b[j+2] = 1;
                    int value = 0;
                    int t = 0;
                    int s = 0;
                    s = s | (1<<b[0]);
                    for(int k = 1; k < j+3; k++){
                        s = s|(1<<b[k]);
                        t += abs(p[i].x[b[k]] - p[i].x[b[k-1]]) + abs(p[i].y[b[k]]-p[i].y[b[k-1]]);
                        value += p[i].value[b[k]];
                    }
                    if(p[i].t[s]<0 || p[i].t[s] > t){
                        p[i].t[s] = t;
                        p[i].v[s] = value;
                    }
                }
            }while(next_permutation(a,a+p[i].m));
        }
        memset(f,-1,sizeof(f));
        f[0][0] = 0;
        int a = 1, b = 0;
        for(int i = 0; i < n; i++)
        {
            a = 1-a;
            b = 1-b;
            for(int j = 0; j < 256; j++){
                if(p[i].t[j] < 0 || p[i].v[j] < 0)continue;
                for(int k = st[i]; k >= 0; k--){

                    if(f[a][k] >= 0 && k+p[i].t[j] <= st[i] && f[b][k+p[i].t[j]] < f[a][k]+p[i].v[j])

                        f[b][k+p[i].t[j]] = f[a][k]+p[i].v[j];
                }
            }
            if(i==0)
                f[a][0] = -1;
            else{
                for(int j = 0; j <= st[i-1]; j++)
                    f[a][j] = -1;
            }
        }
        int ans = -1;
        for(int i = 0; i <= st[n-1]; i++)
        {
            if(f[b][i]>ans)ans = f[b][i];
        }
        if(ans>=0)printf("%d\n",ans);
        else printf("I'm doomed, though I fought bravely\n");
    }
    return 0;
}

patriking 2011-01-15 16:42 发表评论

ZOJ@3453

patriking — Sat, 15 Jan 2011 04:34:00 GMT

ZOJ@3453 题目连接
题意：有N个敌人，排成一排编号为1~n；对于敌人i有一个初始value[i]；对于敌人i，其朋友范围区间[Li,Ri]，i可能在[Li,Ri]区间内。你每次从右边发射子弹，第i颗子弹值为Ki，打中第一个value值大于或等于Ki的敌人，该敌人value值变为1，其朋友范围内的敌人value值均增加1；但是，如果没有敌人的value值大于或者等于Ki，则所有敌人value值增加1。求最后敌人中最高的value值。
解法：线段树，每个节点设置一个max、add元素，max表示该区间上的最大值，add表示该区间增加的值；实现（1）区间段元素+1操作，即对应的区间add+1；（2）对于对某个value值置1，即可将max=-覆盖该点的所有区间add累加值+1；（3）查找大于或等于K的最右元素。

// 2385696      2011-01-14 20:30:00        Accepted      3453      C++      430      6040      redsea
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn = 100005;
int fr[maxn], fl[maxn], value[maxn];
struct node{
    int cr,cl;
    int r,l;
    int max, add;
}st[maxn*2];
int len;
int build(int l,int r, int root)
{
    if(l==r){
        st[root].cr = st[root].cl = -1;
        st[root].r = r;
        st[root].l = l;
        st[root].max = value[l];
        st[root].add = 0;
        return value[l];
    }else{
        int mid = (l+r)/2;
        st[root].r = r;
        st[root].l = l;
        len++;
        int ll = len;
        st[root].cl = ll;
        int m1 = build(l,mid, ll);
        len++;
        int rr = len;
        st[root].cr = rr;
        int m2 = build(mid+1,r,rr);
        st[root].add = 0;
        st[root].max = (m1<m2?m2:m1);
        return st[root].max;
    }
}
int add(int l, int r, int root)
{
    if(root < 0)return -1000000000;
    else if(st[root].l > r || st[root].r < l){
        return -1000000000;
    }
    else if(l <= st[root].l && r >= st[root].r){
        st[root].add++;
        st[root].max++;
        return st[root].max;
    }else{
        int m1 = add(l,r,st[root].cl);
        int m2 = add(l,r,st[root].cr);
        if(m1<m2)m1=m2;
        if(st[root].max < m1+st[root].add)st[root].max = m1+st[root].add;
        return st[root].max;
    }
}
int findMax(int x, int root, int a)
{
    if(st[root].r == st[root].l)
        return st[root].l;
    else{
        int l = st[root].cl;
        int r = st[root].cr;
        if(st[r].max + a+st[root].add >= x)
            return findMax(x,r,a+st[root].add);
        else
            return findMax(x,l,a+st[root].add);
    }
}

int setToOne(int w, int root, int a)
{
    if(st[root].l == st[root].r)
    {
        st[root].add = 0;
        st[root].max = -a + 1;
        return st[root].max;
    }else{
        int l = st[root].cl;
        int r = st[root].cr;
        if(st[l].l <= w && st[l].r >= w){
            int m1 =setToOne(w,l,a+st[root].add);
            int m2 =st[r].max;
            st[root].max = (m1<m2?m2:m1)+st[root].add;
            return st[root].max;
        }else{
            int m1 = setToOne(w,r,a+st[root].add);
            int m2 = st[l].max;
            st[root].max = (m1<m2?m2:m1)+st[root].add;
            return st[root].max;
        }
    }
}
int main()
{
    int n, m, x;
    while(scanf("%d",&n)!=EOF)
    {
        for(int i = 1; i <= n; i++){
            scanf("%d%d%d",value+i,fl+i,fr+i);
        }
        len = 0;
        build(1,n,0);
        scanf("%d",&m);
        while(m--)
        {
            scanf("%d",&x);
            if(st[0].max < x){
                add(1,n,0);
            }
            else{
                int index = findMax(x,0,0);
                setToOne(index,0,0);
                add(fl[index],fr[index],0);
            }
        }
        printf("%d\n",st[0].max);
    }
    return 0;
}

patriking 2011-01-15 12:34 发表评论

ZOJ@3447题解

patriking — Fri, 07 Jan 2011 13:16:00 GMT

摘要: http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=4190题意即通过合并求最大的合并数与最小的合并数之差。最大合并数策略：每次选取最小的两个数合并；最小合并数策略：每次选最大的K个数合并。注意：大数运算。 Code highlighting produced by Actipro CodeHighlighter (freewar... 阅读全文

patriking 2011-01-07 21:16 发表评论

Algorithm@POJ2989题解

patriking — Fri, 07 Jan 2011 09:48:00 GMT

http://acm.pku.edu.cn/JudgeOnline/problem?id=2989
大致题意：给定一个含有n个人的集合S，S中的每两人要么是朋友，要么不是朋友。假如，S的一个子集合S'，S'中任意两个人都互为朋友，且｛S-S'｝中的任意一个人与S'中的某些人不是朋友，则称S'为maximal sets of friends。
求maximal sets of friends的数量，大于1000则输出"Too many maximal sets of friends."，否则输出数量。
解法：
经典解法搜索+减枝。按顺序枚举集合S的子集合，并在枚举子集合的过程中判断子集合是否是maximal sets of friends，鉴于n<128，故使用两个64位的数来表示集合，使用位操作加以优化。

patriking 2011-01-07 17:48 发表评论

patriking Algorithm@POJ3107(树形动态规划)

patriking — Fri, 07 Jan 2011 09:28:00 GMT

http://acm.pku.edu.cn/JudgeOnline/problem?id=3107
题意：给定一棵无根树，删除树中一个节点，剩下各子树的包含的节点数最大值最小，问树中有多少个这样的节点?
解法：任意选择一个节点，作为根，进行遍历。对一个节点V，设其子节点为cv[1..k]，f[v]为以节点v为根的子树包含的节点数。
对于每一个节点V，删除V之后剩下子树含有的节点数中最大分别为 max{ f[cv[1]]，f[cv[2]]，....f[cv[k]]，SumNode-(f[cv[1]]+f[cv[2]]+....+f[cv[k]]) }，一次遍历即可求出所有删除一个节点后的最大子树包含的节点数。

//7044398    Oestrus    3107    Accepted    4164K    688MS    G++    1595B    2010-06-11 22:11:19
#include<iostream>
#include<vector>
#include<algorithm>
#include<stdio.h>
#define MAXN 50005
using namespace std;
vector<int>ansNode;
int maxNumNode;
int n, f[MAXN];
int pointTree[MAXN];
struct Tree{
    int x,y;
}tree[MAXN*2];
int len;
bool cmp(struct Tree a, struct Tree b)
{
    return a.x<b.x;
}
int treedp(int parentNode,int thisNode){
    int maxNode=0;
    int sumChildNode=0;
    int index=pointTree[thisNode];
    do{
        int childNode=tree[index].y;
        if(childNode != parentNode)
        {
            f[childNode]=treedp(thisNode,childNode);
            sumChildNode+=f[childNode];
            if(f[childNode]>maxNode)maxNode=f[childNode];
        }
        index++;
    }while(index<len && tree[index].x==tree[index-1].x);
    if(maxNode<n-sumChildNode-1)maxNode=n-sumChildNode-1;
    if(maxNode<maxNumNode){
        maxNumNode=maxNode;
        ansNode.clear();
        ansNode.push_back(thisNode);
    }else if(maxNode==maxNumNode){
        ansNode.push_back(thisNode);
    }
    return sumChildNode+1;
}

int main(int argc,int *argv[])
{
    while(scanf("%d",&n)!=EOF){
        len=0;
        for(int i=1;i<n;i++){
            int x,y;
            scanf("%d%d",&x,&y);
            tree[len].x=x;
            tree[len++].y=y;
            tree[len].x=y;
            tree[len++].y=x;
        }
        sort(tree,tree+len,cmp);
        pointTree[tree[0].x]=0;
        for(int i=1;i<len;i++){
            if(tree[i].x != tree[i-1].x)
                pointTree[tree[i].x] = i;
        }
        ansNode.clear();
        maxNumNode=n;
        treedp(-1,1);
        sort(ansNode.begin(),ansNode.end());
        for(int i=0;i<ansNode.size();i++)
            printf("%d ",ansNode[i]);
    }
    return 0;
}

patriking 2011-01-07 17:28 发表评论