C++博客-小阮的菜田-随笔分类-数据结构和算法

[网络流]骑士共存问题

小阮 — Mon, 17 Oct 2011 14:03:00 GMT

【问题分析】

二分图最大独立集，转化为二分图最大匹配，从而用最大流解决。

【建模方法】

首先把棋盘黑白染色，使相邻格子颜色不同。把所有可用的黑色格子看做二分图X集合中顶点，可用的白色格子看做Y集合顶点。建立附加源S汇T，从S向X集合中每个顶点连接一条容量为1的有向边，从Y集合中每个顶点向T连接一条容量为1的有向边。从每个可用的黑色格子向骑士一步能攻击到的可用的白色格子连接一条容量为无穷大的有向边。求出网络最大流，要求的结果就是可用格子的数量减去最大流量。

【建模分析】

用网络流的方法解决棋盘上的问题，一般都要对棋盘黑白染色，使之成为一个二分图。放尽可能多的不能互相攻击的骑士，就是一个二分图最大独立集问题。有关二分图最大独立集问题，更多讨论见《最小割模型在信息学竞赛中的应用》作者胡伯涛。

该题规模比较大，需要用效率较高的网络最大流算法解决。

基础概念:

独立集：

独立集是指图的顶点集的一个子集,该子集的导出子图不含边.如果一个独立集不是任何一个独立集的子集, 那么称这个独立集是一个极大独立集.一个图中包含顶点数目最多的独立集称为最大独立集。最大独立集一定是极大独立集，但是极大独立集不一定是最大的独立集。

支配集：

与独立集相对应的就是支配集，支配集也是图顶点集的一个子集，设S 是图G 的一个支配集，则对于图中的任意一个顶点u，要么属于集合s, 要么与s 中的顶点相邻。在s中除去任何元素后s不再是支配集，则支配集s是极小支配集。称G的所有支配集中顶点个数最少的支配集为最小支配集，最小支配集中的顶点个数成为支配数。

最小点的覆盖：

最小点的覆盖也是图的顶点集的一个子集，如果我们选中一个点，则称这个点将以他为端点的所有边都覆盖了。将图中所有的边都覆盖所用顶点数最少，这个集合就是最小的点的覆盖。

最大团：

图G的顶点的子集，设D是最大团，则D中任意两点相邻。若u，v是最大团，则u,v有边相连，其补图u,v没有边相连，所以图G的最大团=其补图的最大独立集。

一些性质：

最大独立集+最小覆盖集=V

最大团=补图的最大独立集

最小覆盖集=最大匹配

小阮 2011-10-17 22:03 发表评论

[网络流] 餐巾计划问题

小阮 — Mon, 17 Oct 2011 13:36:00 GMT

【问题分析】

网络优化问题，用最小费用最大流解决。

【建模方法】

把每天分为二分图两个集合中的顶点Xi,Yi，建立附加源S汇T。

1、从S向每个Xi连一条容量为ri，费用为0的有向边。
2、从每个Yi向T连一条容量为ri，费用为0的有向边。
3、从S向每个Yi连一条容量为无穷大，费用为p的有向边。
4、从每个Xi向Xi+1(i+1<=N)连一条容量为无穷大，费用为0的有向边。
5、从每个Xi向Yi+m(i+m<=N)连一条容量为无穷大，费用为f的有向边。
6、从每个Xi向Yi+n(i+n<=N)连一条容量为无穷大，费用为s的有向边。

求网络最小费用最大流，费用流值就是要求的最小总花费。

【建模分析】

这个问题的主要约束条件是每天的餐巾够用，而餐巾的来源可能是最新购买，也可能是前几天送洗，今天刚刚洗好的餐巾。每天用完的餐巾可以选择送到快洗部或慢洗部，或者留到下一天再处理。

经过分析可以把每天要用的和用完的分离开处理，建模后就是二分图。二分图X集合中顶点Xi表示第i天用完的餐巾，其数量为ri，所以从S向Xi连接容量为ri的边作为限制。Y集合中每个点Yi则是第i天需要的餐巾，数量为ri，与T连接的边容量作为限制。每天用完的餐巾可以选择留到下一天（Xi->Xi+1），不需要花费，送到快洗部(Xi->Yi+m)，费用为f，送到慢洗部(Xi->Yi+n)，费用为s。每天需要的餐巾除了刚刚洗好的餐巾，还可能是新购买的(S->Yi)，费用为p。

在网络上求出的最小费用最大流，满足了问题的约束条件（因为在这个图上最大流一定可以使与T连接的边全部满流，其他边只要有可行流就满足条件），而且还可以保证总费用最小，就是我们的优化目标。

小阮 2011-10-17 21:36 发表评论

ural 1297 最长回文子串(后缀数组)

小阮 — Thu, 30 Jun 2011 15:34:00 GMT

摘要: 题意: 给定一个字符串, 求最长回文串分析: 求一个后缀和一个反过来写的后缀的最长公共前缀。具体的做法是：将整个字符串反过来写在原字符串后面，中间用一个特殊的字符隔开。问题变成求这个新的字符串的某两个后缀的最长公共前缀. Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlight... 阅读全文

小阮 2011-06-30 23:34 发表评论

SPOJ 694 Distinct Substrings(不同子串个数, 后缀数组)

小阮 — Thu, 30 Jun 2011 13:19:00 GMT

题意: 给定一个字符串, 求不相同的子串的个数.

分析:每个子串其实都是一个后缀的前缀, 原题等价于求: 所有后缀之间不相等前缀个数.

所有后缀按照 suffix(sa[1]), suffix(sa[2]), suffix(sa[3]), ... suffix(sa[n])排序,

每新加入一个后缀suffix(sa[k]), 就增加 n - sa[k] + 1 个前缀, 这些前缀中, 又有height[k]个与前一个后缀相同.

所有只是增加个 n-sa[k]+1-height[k];

整理下求和公示.

#include <stdio>
#include <cstring>

using namespace std;

const int  maxn = 1003

#define F(x) ((x)/3+((x)%3==1?0:tb))
#define G(x) ((x)

int wa[maxn],wb[maxn],wv[maxn],ws[maxn];

int c0(int *r,int a,int b){
    return r[a]==r[b]&&r[a+1]==r[b+1]&&r[a+2]==r[b+2];
}

int c12(int k,int *r,int a,int b){
    if(k==2)
        return r[a]<r[b]||r[a]==r[b]&&c12(1,r,a+1,b+1);
    else
        return r[a]<r[b]||r[a]==r[b]&&wv[a+1]<wv[b+1];
}

void sort(int *r,int *a,int *b,int n,int m){
     int i;
     for(i=0;i<n;i++) wv[i]=r[a[i]];
     for(i=0;i<m;i++) ws[i]=0;
     for(i=0;i<n;i++) ws[wv[i]]++;
     for(i=1;i<m;i++) ws[i]+=ws[i-1];
     for(i=n-1;i>=0;i--) b[--ws[wv[i]]]=a[i];
     return;
}

void dc3(int *r,int *sa,int n,int m){
     int i,j,*rn=r+n,*san=sa+n,ta=0,tb=(n+1)/3,tbc=0,p;
     r[n]=r[n+1]=0;
     for(i=0;i<n;i++) if(i%3!=0) wa[tbc++]=i;
     sort(r+2,wa,wb,tbc,m);
     sort(r+1,wb,wa,tbc,m);
     sort(r,wa,wb,tbc,m);
     for(p=1,rn[F(wb[0])]=0,i=1;i<tbc;i++)
     rn[F(wb[i])]=c0(r,wb[i-1],wb[i])?p-1:p++;
     if(p<tbc) dc3(rn,san,tbc,p);
     else for(i=0;i<tbc;i++) san[rn[i]]=i;
     for(i=0;i<tbc;i++) if(san[i]<tb) wb[ta++]=san[i]*3;
     if(n%3==1) wb[ta++]=n-1;
     sort(r,wb,wa,ta,m);
     for(i=0;i<tbc;i++) wv[wb[i]=G(san[i])]=i;
     for(i=0,j=0,p=0;i<ta && j<tbc;p++)
     sa[p]=c12(wb[j]%3,r,wa[i],wb[j])?wa[i++]:wb[j++];
     for(;i<ta;p++) sa[p]=wa[i++];
     for(;j<tbc;p++) sa[p]=wb[j++];
     return;
}

int rank[maxn],height[maxn];

void calheight(int *r,int *sa,int n){
     int i,j,k=0;
     for(i=1;i<=n;i++) rank[sa[i]]=i;
     for(i=0;i<n;height[rank[i++]]=k)
     for(k?k--:0,j=sa[rank[i]-1];r[i+k]==r[j+k];k++);
     return;
}

char s[maxn];
int r[maxn*3],sa[maxn*3];

int main(){
    int i,n,t,ans;
    scanf("%d",&t);
    while(t-->0){
      scanf("%s",s);
      n=strlen(s);
      for(i=0;i<n;i++) r[i]=s[i];
      r[n]=0;
      dc3(r,sa,n+1,128);
      calheight(r,sa,n);
      ans=n*(n+1)/2;
      for(i=1;i<=n;i++) ans-=height[i];
      printf("%d\n",ans);
    }
    return 0;
}

小阮 2011-06-30 21:19 发表评论

并查集类

小阮 — Tue, 03 May 2011 12:27:00 GMT

并查集提供的操作：
1. 合并两个集合。
2. 判断两个元素是否在同一个集合里边。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>

using namespace std;

const int MAXN=1001;

class UFS{
    public:
    int F[MAXN];
    tUFS(){
        for (int i=1;i<MAXN;i++)F[i]=-i;
    }
    int findroot(int a){
        int r=a,t;
        while (F[r]>0) r=F[r];
        while (F[a]>0) {t=F[a];F[a]=r;a=t;}
        return r;
    }
    void Union(int a,int b){
        F[findroot(a)]=findroot(b);
    }
    bool Judge(int a,int b){
        return F[findroot(a)]==F[findroot(b)];
    }
    int getroot(int a){
        return -F[findroot(a)];
    }
};

小阮 2011-05-03 20:27 发表评论

次短路径与次小生成树问题的简单解法

小阮 — Tue, 03 May 2011 12:21:00 GMT

[次短路径]

次短路径可以看作是k短路径问题的一种特殊情况，求k短路径有Yen算法等较为复杂的方法，对于次短路径，可以有更为简易的方法。下面介绍一种求两个顶点之间次短路径的解法。

我们要对一个有向赋权图(无向图每条边可以看作两条相反的有向边)的顶点S到T之间求次短路径，首先应求出S的单源最短路径。遍历有向图，标记出可以在最短路径上的边，加入集合K。然后枚举删除集合K中每条边，求从S到T的最短路径，记录每次求出的路径长度值，其最小值就是次短路径的长度。

在这里我们以为次短路径长度可以等于最短路径长度，如果想等，也可以看作是从S到T有不止一条最短路径。如果我们规定求从S到T大于最短路径长度的次短路径，则答案就是每次删边后大于原最短路径的S到T的最短路径长度的最小值。

用Dijkstra+堆求单源最短路径，则每次求最短路径时间复杂度为O(N*log(N+M) + M)，所以总的时间复杂度为O(N*M*log(N+M) + M^2)。该估计是较为悲观的，因为一般来说，在最短路径上的边的条数要远远小于M，所以实际效果要比预想的好。

[次小生成树]

类比上述次短路径求法，很容易想到一个“枚举删除最小生成树上的每条边，再求最小生成树”的直观解法。如果用Prim+堆，每次最小生成树时间复杂度为O(N*log(N+M) + M)，枚举删除有O(N)条边，时间复杂度就是O(N^2*log(N+M) + N*M)，当图很稠密时，接近O(N^3)。这种方法简易直观，但我们有一个更简单，而且效率更高的O(N^2+M)的解法，下面介绍这种方法。

首先求出原图最小生成树，记录权值之和为MinST。枚举添加每条不在最小生成树上的边(u,v)，加上以后一定会形成一个环。找到环上权值第二大的边(即除了(u,v)以外的权值最大的边)，把它删掉，计算当前生成树的权值之和。取所有枚举修改的生成树权值之和的最小值，就是次小生成树。

具体实现时，更简单的方法是从每个节点i遍历整个最小生成树，定义F[j]为从i到j的路径上最大边的权值。遍历图求出F[j]的值，然后对于添加每条不在最小生成树中的边(i,j)，新的生成树权值之和就是MinST + w(i,j) – F[j]，记录其最小值，则为次小生成树。

该算法的时间复杂度为O(N^2 + M)。由于只用求一次最小生成树，可以用最简单的Prim，时间复杂度为O(N^2)。算法的瓶颈不在求最小生成树，而在O(N^2+M)的枚举加边修改，所以用更好的最小生成树算法是没有必要的。

[次短路径与次小生成树的例题]

HAOI 2005 路由选择问题
直接求次短路径。

pku 3255 Roadblocks
稍微特殊的次短路径，允许边重复走。

Ural 1416 Confidential
求次小生成树的问题、

pku 1679 The Unique MST
判断最小生成树是否唯一。

http://www.byvoid.com/blog/2-sp-mst/

小阮 2011-05-03 20:21 发表评论

高精计算

小阮 — Tue, 12 Apr 2011 11:42:00 GMT

摘要: #include using namespace std; template class hp{ public: ... 阅读全文

小阮 2011-04-12 19:42 发表评论

pku 1204 Word Puzzles (trie)

小阮 — Tue, 15 Mar 2011 16:41:00 GMT

题意：给定一个n*m的字符阵列中，查找给出字串匹配的开始坐标位置，配置可以是从开始坐标向四周8个方向。

分析：对需要匹配的字串建立trie树，枚举字符阵列的每个位置，每个方向，进行查询。

#include <iostream>

using namespace std;

const int MAX = 90000;
const int M = 26, N = 1005, W=1005;
const int DX[] = { -1,-1,  0,  1,  1,  1,  0, -1 };
const int DY[] = { 0,  1,  1,  1,  0, -1, -1, -1 };
const char D[] = {'A','B','C','D','E','F','G','H'};
int sx,sy;
int n,m,w;
int index;
char puzzles[N][N], word[W];
int r[W][3];

struct Node{
    int end;
    struct Node* child[M];
    Node(){
        end=-1;
        memset(child,NULL,sizeof(child));
    }
};

Node tree;
Node *root = &tree;

void insert( char* s, int d){
    Node *node = root;
    while(*s){
        if(index==20){
            printf(" ");
        }
        if(node->child[*s-'A']==NULL){
            node->child[*s-'A'] = new Node;
        }
        node=node->child[*s-'A'];
        s++;
    }
    node->end = d;
}

void search(int x, int y, int d){
    Node *node = root->child[puzzles[x][y]-'A'];

    if(node==NULL)
        return;

    while(node){
        if(node->end>-1){
            r[node->end][0] = sx;
            r[node->end][1] = sy;
            r[node->end][2] = d;
        }
        x=x+DX[d];
        y=y+DY[d];
        if( x>=0 && x<n && y>=0 && y<m ){
            node=node->child[puzzles[x][y]-'A'];
        }else
            break ;
    }
    return;
}

void solve(){
    int i,j,k;
    for(i=0;i<n;++i)
        for(j=0;j<m;++j)
            for(k=0;k<8;++k){
                sx = i;
                sy = j;
                search(i,j,k);
            }
}

int main(){
    int i;
    scanf("%d%d%d", &n, &m, &w);
    for(i=0;i<n;++i){
        scanf("%s", &puzzles[i]);
    }
    for(i=0;i<w;++i){
        scanf("%s", &word[i]);
        insert(&word[i],i);
    }

    solve();

    for(i=0;i<w;++i)
        printf("%d %d %c\n", r[i][0], r[i][1], D[r[i][2]]);

    return 0;
}

小阮 2011-03-16 00:41 发表评论

pku 1200 Crazy Search (Rabin Karp)

小阮 — Tue, 15 Mar 2011 16:08:00 GMT

题意：统计由d个不同字符组成的串中，长度为n的不同字串数目。

分析：Rabin Karp

Rabin-Karp 算法（以下简称为 RK 算法），是基于这样的思路：即把串看作是字符集长度进制的数，由数的比较得出字符串的比较结果。例如，给定字符集为∑ ={0,1,2,3,4,5,6,7,8,9} ，∑长度为 d=10 ，那么任何以∑为字符集的串都可看作 d （此处为 10 ）进制的数。

记模式串 P[0..n-1] 对应的数值为 P ， T[0..n-1] 所有长度为 m 的子串对应的数值为 t_s ，设 P 和 T 都是基于字符集长度为 | ∑ |=d 的字符串。

那么， t_s 即为 T[s..s+m] 对应的数值，这里 0<=s<=n-m-1 。

P = P[m]+d*(P[m-1]+d*(P[m-2]+..)))

同样 t₀ 也可类似求得。

最重要的是如何从 t_s 求出 t_s+1 。

t_s+1 =T[s+m]+d*(t_s +d^m-1 *T[s])

注：此处是该算法的关键，即在常数时间内能够计算出下一个 m 长度的字串对应的数值。初看比较抽象，举个例子就比较明白了，设 x=12345 ，现在是已知长度为 3 的数值 234 ，现在要求 345 对应的数值，可以这样来得到： 345 = 5 + 10*(234-10² *2)

#include <iostream>

using namespace std;

const int MAX = 100000000;

bool hash[MAX];
char text[MAX];
int key[256],c[10000], ans;

int main(){
    int i, n,d,len;

    //freopen("input.txt","r", stdin);

    scanf("%d%d", &n, &d);
    scanf("%s", text);
    len = strlen(text);
    //init
    c[0]=1;
    for(i=1; i<10000; i++)
        c[i] = c[i-1]*d;

    int k=0;
    for(i=0; i<len; ++i){
        if(key[text[i]]==0)
            key[text[i]]=k++;

        if(k==d)
            break;
    }

    //sovle
    int h=0;
    for(i=0; i<n; ++i)
        h = h*d + key[text[i]];

    hash[h]=true;
    ans++;

    for(i=0; i<len-n; ++i){
        h = d*(h-c[n-1]*key[text[i]]) + key[text[i+n]];
        if(!hash[h]){
            hash[h]=true;
            ans++;
        }
    }

    printf("%d\n", ans);

    return 0;
}

小阮 2011-03-16 00:08 发表评论

[网络流] 方格取数问题 ( 二分图点权最大独立集, 最小割模型, 最大流)

小阮 — Mon, 14 Mar 2011 15:20:00 GMT

【问题分析】

二分图点权最大独立集，转化为最小割模型，从而用最大流解决。

【建模方法】

首先把棋盘黑白染色，使相邻格子颜色不同，所有黑色格子看做二分图X集合中顶点，白色格子看做Y集合顶点，建立附加源S汇T。

1、从S向X集合中每个顶点连接一条容量为格子中数值的有向边。
2、从Y集合中每个顶点向T连接一条容量为格子中数值的有向边。
3、相邻黑白格子Xi,Yj之间从Xi向Yj连接一条容量为无穷大的有向边。

求出网络最大流，要求的结果就是所有格子中数值之和减去最大流量。

【建模分析】

这是一个二分图最大点权独立集问题，就是找出图中一些点，使得这些点之间没有边相连，这些点的权值之和最大。独立集与覆盖集是互补的，求最大点权独立集可以转化为求最小点权覆盖集（最小点权支配集）。最小点权覆盖集问题可以转化为最小割问题解决。结论:最大点权独立集 = 所有点权 - 最小点权覆盖集 = 所有点权 - 最小割集 = 所有点权 - 网络最大流。

对于一个网络，除去冗余点（不存在一条ST路径经过的点），每个顶点都在一个从S到T的路径上。割的性质就是不存在从S到T的路径，简单割可以认为割边关联的非ST节点为割点，而在二分图网络流模型中每个点必关联到一个割点（否则一定还有增广路，当前割不成立），所以一个割集对应了一个覆盖集（支配集）。最小点权覆盖集就是最小简单割，求最小简单割的建模方法就是把XY集合之间的变容量设为无穷大，此时的最小割就是最小简单割了。

有关二分图最大点权独立集问题，更多讨论见《最小割模型在信息学竞赛中的应用》作者胡伯涛。

小阮 2011-03-14 23:20 发表评论

[网络流] 试题库问题 (二分图多重匹配, 最大流)

小阮 — Sun, 13 Mar 2011 15:53:00 GMT

【问题分析】

二分图多重匹配问题，用最大流解决。

【建模方法】

建立二分图，每个类别为X集合中的顶点，每个题为Y集合中的顶点，增设附加源S和汇T。

1、从S向每个Xi连接一条容量为该类别所需数量的有向边。
2、从每个Yi向T连接一条容量为1的有向边。
3、如果一个题i属于一个类别j，连接一条从Xj到Yi容量为1的有向边。

求网络最大流，如果最大流量等于所有类别所需之和，则存在解，否则无解。对于每个类别，从X集合对应点出发的所有满流边，指向的B集合中的顶点就是该类别的所选的题（一个可行解）。

【建模分析】

二分图多重匹配问题。X，Y集合之间的边容量全部是1，保证两个点只能匹配一次，源汇的连边限制了每个点匹配的个数。求出网络最大流，如果流量等于X集合所有点与S边容量之和，那么则说明X集合每个点都有完备的多重匹配。

小阮 2011-03-13 23:53 发表评论

[网络流] 最长递增子序列问题 (DP, 最大流)

小阮 — Thu, 10 Mar 2011 03:10:00 GMT

题意：
Q1：LIS，最长长度为s
Q2：有多少个长度为s的子序列
Q3：若A[1]和A[n]可多次使用，问可以取多少个s长度的子序列

建模：

Q1：LIS，DP， F[i]表示以第i位为开头的最长上升序列的长度，求出最长上升序列长度K

for (int i=N;i>=1;i--){
    F[i] = 1;
    for (int j=i+1;j<=N;j++)
        if (A[j] > A[i] && F[j]+1 > F[i])
            F[i] = F[j]+1;
    if (F[i] > Ans)
        Ans = F[i];
}

Q2：
1、把序列每位i拆成两个点和，从到连接一条容量为1的有向边。
2、建立附加源S和汇T，如果序列第i位有F[i]=K，从S到连接一条容量为1的有向边。
3、如果F[i]=1，从到T连接一条容量为1的有向边。
4、如果j>i且A[i] < A[j]且F[j]+1=F[i]，从到连接一条容量为1的有向边。

求最大流，为第二问的解。

Q3：令(<1.a>,<1.b>)(,)(S,<1.a>)(,T)这四条边的容量修改为无穷大，再求一次网络最大流，就是第三问结果。

小阮 2011-03-10 11:10 发表评论

[网络流] 圆桌问题 (二分图多重匹配, 最大流)

小阮 — Wed, 09 Mar 2011 04:50:00 GMT

题意：
n个不同单位，每个单位ri 人；m个桌子，每个桌子坐ci人；同一个单位的人不坐在一个桌子上，给出所有可能的方案。

建模：
建立二分图，每个单位为X集合中的结点，每个桌子为Y集合的结点，增加源点S和汇点T。

1. 添加 S->Xi，且权值为第i个单位的人数。
2. 添加 Yi->T，且权值为第i个桌子可容纳的人数。
3.添加 Xi ->Yi，且权值为1。

求网络最大流，如果最大流量等于所有单位人数之和，则存在解，否则无解。对于每个单位，从X集合对应点出发的所有满流边指向的Y集合的顶点就是该单位人员的安排情况（一个可行解）。

分析：
对于二分图，每个定点可以有多个匹配，称这类问题为二分图多重匹配。X，Y集合之间的边容量全部是1，保证两个点只能匹配一次（一个餐桌上只能有一个单位的一个人），源汇的连边限制了每个点匹配的个数。求出网络最大流，如果流量等于X集合所有点与S边容量之和，那么则说明X集合每个点都有完备的多重匹配。

小阮 2011-03-09 12:50 发表评论

[网络流] 魔术球问题 (枚举, 最小路径覆盖, 二分图最大匹配, 最大流)

小阮 — Tue, 08 Mar 2011 13:42:00 GMT

【问题分析】

枚举答案转化为判定性问题，然后最小路径覆盖，可以转化成二分图最大匹配，从而用最大流解决。

【建模方法】

枚举答案A，在图中建立节点1..A。如果对于i

具体方法可以顺序枚举A的值，当最小路径覆盖数刚好大于N时终止，A-1就是最优解。

【建模分析】

由于是顺序放球，每根柱子上的球满足这样的特征，即下面的球编号小于上面球的编号。抽象成图论，把每个球看作一个顶点，就是编号较小的顶点向编号较大的顶点连接边，条件是两个球可以相邻，即编号之和为完全平方数。每根柱子看做一条路径，N根柱子要覆盖掉所有点，一个解就是一个路径覆盖。

最小路径覆盖数随球的数量递增不递减，满足单调性，所以可以枚举答案（或二分答案），对于特定的答案求出最小路径覆盖数，一个可行解就是最小路径覆盖数等于N的答案，求出最大的可行解就是最优解。本问题更适合枚举答案而不是二分答案，因为如果顺序枚举答案，每次只需要在残量网络上增加新的节点和边，再增广一次即可。如果二分答案，就需要每次重新建图，大大增加了时间复杂度。

小阮 2011-03-08 21:42 发表评论

[网络流]最小路径覆盖问题 (二分图最大匹配, 最大流)

小阮 — Sat, 05 Mar 2011 15:29:00 GMT

摘要: 题意：有向无环图中，需要多少条简单路可以覆盖整个图。建模：构造二分图。把原图的每个顶点i拆分成二分图X，Y集合中的两个顶点Xi和Yi。对于原图的边(i, i)，连接(Xi, Yj)，值为1，然后把二分图最大匹配模型转化为网络留模型，求最大流。分析：对于一个路径覆盖，有如下性质： 1、每个顶点属于且只属于一个路径。2、路径上除终点外，从每个顶点出发只有一条边指向路径上的另一顶点。所以我们可... 阅读全文

小阮 2011-03-05 23:29 发表评论

[网络流]太空飞行计划问题 (最大权闭合图)

小阮 — Wed, 02 Mar 2011 04:32:00 GMT

摘要: 把每个实验看作二分图X集合中的顶点，每个设备看作二分图Y集合中的顶点，增加源S和汇T。1、从S向每个Xi连接一条容量为该点收入的有向边。2、从Yi向T连接一条容量为该点支出的有向边。3、如果一个实验i需要设备j，连接一条从Xi到Yj容量为无穷大的有向边。统计出所有实验的收入只和Total，求网络最大流Maxflow，最大收益就是Total-Maxflow。对应的解就是最小割划分出的S集合中的点... 阅读全文

小阮 2011-03-02 12:32 发表评论

[网络流]飞行员配对方案问题 (二分图最大匹配问题, 最大流)

小阮 — Thu, 24 Feb 2011 04:35:00 GMT

摘要: 题意：二分图最大匹配问题。解法1：匈牙利算法。解法2：最大流。添加原点s和汇点t。设二分图左边的点集为X，添加从s 到X（1,2,....,m ）的边，权值为1；右边的点集为Y，添加从Y（n-m+1, n-m+1, .... , n）到t 的边，权值为1；田间X和Y之间的边。求最大流。我用Dinic。最大流就是最大匹配。配对保存在flow[i][j]中。 #include 阅读全文

小阮 2011-02-24 12:35 发表评论

字符串Hash算法

小阮 — Wed, 23 Feb 2011 14:16:00 GMT

摘要: 据说，Hash的优劣顺序为：BKDRHash, APHash, DJBHash, JSHash, RSHash, SDBMHash, PJWHash, ELFHash。 unsigned int SDBMHash(char *str){ unsigned int hash = 0;... 阅读全文

小阮 2011-02-23 22:16 发表评论

克莱姆法则

小阮 — Thu, 23 Dec 2010 08:02:00 GMT

小阮 2010-12-23 16:02 发表评论

后缀数组

小阮 — Tue, 02 Nov 2010 13:47:00 GMT

摘要: // for pairsinline bool leq(int a1, int a2, int b1, int b2){ return (a1阅读全文

小阮 2010-11-02 21:47 发表评论