2014年10月 西安赛区模板

1 头文件

#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#define INF 1e9

2 图论

2.1 建图

int ind
;
int t[M], nt[M], c[M], p[M];

void add(int i, int j, int w)
{
cnt++;
t[cnt] = j;
c[cnt] = w;
nt[cnt] = ind[i];
p[cnt] = cnt + 1;
ind[i] = cnt;
}

2.2 SAP

int aug(int x, int lim)
{
if(x == ed) { return lim; }
int l = lim;
int minh = n + 1;
for(int k = ind[x]; k != -1; k = nt[k])
if(c[k])
{
if(h[t[k]] == h[x] - 1)
{
int d = aug(t[k], min(c[k], l));
c[k] -= d;
c[p[k]] += d;
l -= d;
if(l == 0) break;
if (h[st] > n) { return lim - l; }
}
minh = min(minh, h[t[k]]);
}

if(l == lim)
{
hv[h[x]]--;
if(hv[h[x]] == 0) { h[st] = n + 1; return lim - l; }
h[x] = minh + 1;
hv[h[x]]++;
}
return lim - l;
}

int sap(int ss, int ee)
{
st = ss; ed = ee;
memset(h, 0, sizeof h);
memset(hv, 0, sizeof hv);
hv[st] = n + 1;
int ans = 0;
while(h[st] < n + 1)
{
ans += aug(st, INF);
}
return ans;
}

2.3 DINIC

Function BFS(): Boolean;
Var
l, r, k, x: Longint;
Begin
Fillchar(Vis, Sizeof(Vis), False);
Fillchar(h, Sizeof(h), 0);
l := 0;
r := 0;
q[l] := st;
Vis[st] := True;
While l <= r Do
Begin
x := q[l];
k := Ind[q[l]];
Inc(l);
While k <> -1 Do
Begin
If (c[k] > 0) And (Not Vis[t[k]]) Then
Begin
h[t[k]] := h[x] + 1;
Inc(r);
q[r] := t[k];
Vis[t[k]] := True;
End;
k := nt[k];
End;
End;
If h[ed] = 0 Then BFS := False Else BFS := True;
End;

Function DFS(x, lim: Longint): Longint;
Var
k, l, d: Longint;
Begin
If x = ed Then Begin DFS := Lim; Exit; End;
k := Ind[x];
L := Lim;
dFS := 0;
While k <> -1 Do
Begin
If h[t[k]] = h[x] + 1 Then
Begin
d := DFS(t[k], Min(l, c[k]));
Dec(c[k], d);
Inc(c[p[k]], d);
Dec(l, d);
If l = 0 Then Break;
End;
k := nt[k];
End;
DFS := Lim - l;
End;

Function Dinic(): Longint;
Begin
Dinic := 0;
While BFS Do Dinic := Dinic + DFS(st, MaxLongint);
End;

2.4 2-SAT(TARJAN)

void tarjan(int x)
{
num++;
dfn[x] = low[x]= num;
s[++l] = x;
vis[x] = true;
for(int k = ind[x]; k != -1; k = nt[k])
{
if(dfn[t[k]] == 0) tarjan(t[k]);
if(vis[t[k]]) low[x] = min(low[x], low[t[k]]);
}

if(dfn[x] == low[x])
{
idn++;
while(true)
{
int tmp = s[l--];
id[tmp] = idn;
vis[tmp] = false;
if(tmp == x) break;
}
}
}

bool chk(double r)
{
cnt = 0;
l = 0;
idn = 0;
memset(vis, 0, sizeof vis);
num = 0;
for(int i = 0; i < 4 * n; i++) ind[i] = -1;
memset(dfn, 0, sizeof dfn);
memset(low, 0, sizeof low);
memset(id, 0, sizeof id);
for(int i = 0; i < 2 * n; i++)
{
for(int j = i + 1; j < 2 * n; j++)
{
if((i ^ 1) != j && point[i].dis(point[j]) < 4.0 * r * r)
{
add(i, j ^ 1);
add(j, i ^ 1);
}
}
}
for(int i = 0; i < 2 * n; i++)
{
if(dfn[i] == 0) tarjan(i);
}
for(int i = 0; i < 2 * n; i++)
{
if(id[i] == id[i ^ 1]) return false;
}
return true;
}

2.5 KM

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#define INF 1000000000
#define N 1000

using namespace std;

double x
, y
, x2
, y2
;
int link
;
double lx
, ly
;
bool visx
, visy
;
double slack
;
int n;

double sqr(double x) { return x * x; }

double dis(int i, int j)
{
return -sqrt( sqr( x[i] - x2[j] ) + sqr( y[i] - y2[j] ) );
}

bool dcmp(double x) { if (fabs(x) < 1e-8) return 1; return 0; }

int dfs(int x)
{
visx[x] = true;
for(int i = 0; i < n; i++)
{
if(!visy[i])
{
double t = lx[x] + ly[i] - dis(x, i);
if(dcmp(t))
{
visy[i] = true;
if(link[i] == -1 || dfs(link[i]))
{
link[i] = x;
return 1;
}
}
else slack[i] = min(t, slack[i]);
}
}
return 0;
}

int main()
{
freopen("ants.in", "r", stdin);
freopen("ants.out", "w", stdout);
cin >> n;
for(int i = 0; i < n; i++) scanf("%lf%lf", &x2[i], &y2[i]);
for(int i = 0; i < n; i++) scanf("%lf%lf", &x[i], &y[i]);

memset(ly, 0, sizeof ly);
for(int i = 0; i < n; i++) lx[i] = -INF;
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
{
lx[i] = max(lx[i], dis(i, j));
ly[i] = 0;
}
for(int i = 0; i < n; i++)
{
link[i] = -1;
}
for(int x = 0; x < n; x++)
{
for(int i = 0; i < n; i++) slack[i] = INF;
while(true)
{
memset(visx, 0, sizeof visx);
memset(visy, 0, sizeof visy);
if(dfs(x)) break;
double d = INF;
for(int i = 0; i < n; i++)
if(!visy[i]) d = min(d, slack[i]);
for(int i = 0; i < n; i++)
if(visx[i]) lx[i] -= d;
for(int i = 0; i < n; i++)
{
if(visy[i]) ly[i] += d;
else slack[i] -= d;
}

}
}
for(int i = 0; i < n; i++)
{
cout << link[i] + 1 << endl;
}
fclose(stdout);
}

2.6 割点/割边

割点将一个图分成了两部分，设从任一部分的任一点出发对图进行DFS遍历，当遍历递归到割点后，就进入了图的第二部分。又因为每个点只能visit一次，所以第二部分的点不论怎样遍历再也回不到第一部分了。当所有点(第二部分中)都被访问完后，才回溯到割点，再继续向上回溯。 在DFS的过程中，记录每个点u在DFS树中的标号n1(放在dep[u]中)，以及该点所能到达的最小顺序号n2(存在low[u]中)。注意：这个n2在求取时，是递归进行的，从u的子孙们的low值n2与u的祖先

们的dep值n1(此时u祖先的low值还未求出，dep相当于它的low值)中挑出最小的。这就给了u的儿子们low值比u还小的机会。然而，如果u是割点，那么u孩子们的low值就决然 >= u 了。这也就成了判断u是割点的方法。

至于割边，可以再判断u是否为割点的同时，顺便判断<u,u儿子i>是否为割边。只要满足low[i]>u就行了。

另外，对于dfs起点就是一个割点的情况：如果不是割点，那它必然只有一个儿子(其他连接都被dfs回溯掉了)。它必须是割点，才能保证它的几个儿子不被dfs回溯掉。

注意：想要记录割点u切去后增加的连通分量数目。不能简单的记录u的孩子数，而必须在判断u为割点成立的地方进行统计。即有多少个证明了u是割点的孩子，它们就是u在切除后生成的新连通分量。割点u的某些孩子不一定能证明u是割点，因为它可能与比u小的某个点相连，从而使自己的low值比u还小，这与具体的dfs树有关，即遍历的顺序有关。 可见末尾的一组数据，对同一个图的描述，由于建树的方式不同，导致3的儿子4，不能证明3是割点。从而使3的孩子数(3) ！= 3造就

的连通分量数2（删除3后，两棵子树成为连通分量）。

针对这点再强调一点：对根节点删掉自己后，就只剩新生的联通分量了。不同于枝节点，还有旧的连通分量在。
割点

int cnt = 0;
dfs(int v,int father, int depth) //v是当前结点，father父节点，depth记录dfs标号
{
//WHITE：标未访问
//GREY： 标访问到了，任在处理中
//BLACK: 标处理完毕。
col[v] = GREY; dep[v] = depth;
child = 0; // child 记录v的孩子数

for (每个与v相邻的点i)
{
// 先于v受到遍历的节点们，它们可能是v的祖先。
if (i != father && col[i] == GREY) //别把father当成孩子结点
low[v] = min(low[v], dep[i]); //更新low[v]
if (col[i] == WHITE) // 这是v的子节点们，它们尚未被访问
{
dfs(i, v, depth+1);
child = child + 1;

//更新v结点的low值，注意此时v子孙们的low值早已求完，尘埃落定了。
low[v] = min(low[v], low[i]);

if ((v为根 && child > 1) || (v不为根 && low[i] >= dep[v]))//证明u是割点
{ v为割点;    cnt++ ;}//判割点；cnt记录切去v后增加的分量数目

if (low[i] > dep[v])
<V,I>为割边;     //判割边
}
}
col[v] = BLACK; //标记v已处理完毕
}

割边:

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

const int N = 110;
const int WHITE = 0,GREY = 1,BLACK = 2; //标记值
int map

;
int col
,low
,dep
;//color
int n,m;
bool tag
;//标记点i是否割点

//求0-1图的割点
void dfs(int now,int father,int depth){
col[now] = GREY;
dep[now] = depth;
int child = 0;
for(int i=1;i<=n;i++){
if(map[now][i]==0)continue;

if(i != father && col[i] == GREY)
low[now] = min(low[now], dep[i]);//low需要被初始化成大数
if(col[i] == WHITE){
dfs(i, now, depth+1);
child = child + 1;
low[now] = min(low[now], low[i]);

if((now==1&&child>1)||(now!=1&&low[i]>=dep[now])) //判割点
tag[now] = 1;//注意：需要记录该割点增加几个联通分量的操作需要在这里cnt++
}
}
col[now] = BLACK;
}

void init(){
memset(map,0,sizeof(map));
memset(col,0,sizeof(col));
memset(tag,0,sizeof(tag));
for(int i=0;i<=n;i++)low[i]=INT_MAX; //low应该被初始化成大值
}

int main(){
int a,b;
cin>>n>>m;
init();
for(int i=0;i<m;i++){
cin>>a>>b;
map[a][b] = map[b][a] = 1;//无向图
}

dfs(1,1,0);//dfs(root,root,0)的形式调用就行了
int ans=0;

for(int i=1;i<=n;i++)
if(tag[i])cout<<i<<' ';

cout<<endl;
system("pause");
return 0;
}
/*
4 4
1 2
2 4
1 3
2 3

*//*
5 5
0 3
3 4
3 1
4 2
0 2
3       //3有3个孩子
5 5
0 2
2 4
0 3
3 4     //3只有2个新生连通分量
3 1
2
*/

3 数据结构

3.1 AC自动机

struct node
{
int p;
char c;
node *nt[26];
node *fail;
node(){p = -1; memset(nt, 0, sizeof nt); fail = NULL;}
void init(){p = -1; memset(nt, 0, sizeof nt); fail = NULL;}
}*top, f[60001];
char a[2001][51];
int dic[200], dcnt;
char s[3000000];
int ans[2001];
node* q[60001];
int cnt;
int l, r;
int len;
node *x, *p, *k;
char buf;

int get(char p)
{
if(dic[p] == -1) dic[p] = dcnt++;
return dic[p];
}

void dfs(node *x)
{
rep(i, dcnt) if(x->nt[i]) dfs(x->nt[i]);
if(x->p != -1 && x->fail->p != -1) ans[x->fail->p] += ans[x->p];
}

int main()
{
int n;
while(~scanf("%d", &n))
{
dcnt = 0;
memset(dic, -1, sizeof dic);
cnt = 0;
top = &f[0];
rep(ii, n)
{
scanf("%s", a[ii]);
len = strlen(a[ii]);
k = top;
rep(i, len)
{
if(k->nt[get(a[ii][i])] == NULL)
k->nt[get(a[ii][i])] = &f[++cnt];
k = k->nt[get(a[ii][i])];
k->c = a[ii][i];
}
k->p = ii;
}
top->fail = top;
l = 0, r = -1;
rep(i, dcnt) if(top->nt[i]) {top->nt[i]->fail = top; q[++r] = top->nt[i];}
while(l <= r)
{
x = q[l];
l++;
k = x->fail;
while(k != top && k->nt[get(x->c)] == NULL)k = k->fail;
if(k->nt[get(x->c)] != NULL && k->nt[get(x->c)] != x) k = k->nt[get(x->c)];
x->fail = k;
rep(i, dcnt) if(x->nt[i]) {x->nt[i]->fail = x->fail; q[++r] = x->nt[i];}
}
memset(ans, 0, sizeof ans);
k = top;
scanf("%s", s);
len = strlen(s);
rep(i, len)
{
buf = s[i];
if(buf < 'A' || buf > 'Z') {k = top ; continue;}
while(k != top && k->nt[get(buf)] == NULL) k = k->fail;
if(k->nt[get(buf)] != NULL) k = k->nt[get(buf)];
if(k->p != -1) ans[k->p]++;
}
dfs(top);
bool flg = true;
for(int i = 0; i < n; i++) if(ans[i] != 0) {printf("%s: %d\n", a[i], ans[i]); flg = false;}
if(flg) putchar('\n');
rep(i, cnt + 1) f[i].init();
}
}

3.2 后缀数组

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

using namespace std;

const int maxn = 1000;
int rank[maxn],wb[maxn],wv[maxn],wss[maxn];
int n;

bool cmp(int *r,int a,int b,int l)
{
return r[a]==r[b] && r[a+l]==r[b+l];
}

void da(int *r,int *sa,int n,int m)
{
int i,j,p,*x=rank,*y=wb,*t;
for(i=0;i<m;i++) wss[i]=0;
for(i=0;i<n;i++) wss[x[i]=r[i]]++;
for(i=1;i<m;i++) wss[i]+=wss[i-1];
for(i=n-1;i>=0;i--)
sa[--wss[x[i]]]=i;

for(j=1,p=1;p<n;j*=2,m=p)
{
for(p=0,i=n-j;i<n;i++) y[p++]=i;
for(i=0;i<n;i++) if(sa[i]>=j) y[p++]=sa[i]-j;
for(i=0;i<n;i++) wv[i]=x[y[i]];
for(i=0;i<m;i++) wss[i]=0;
for(i=0;i<n;i++) wss[wv[i]]++;
for(i=1;i<m;i++) wss[i]+=wss[i-1];
for(i=n-1;i>=0;i--) sa[--wss[wv[i]]]=y[i];
for(t=x,x=y,y=t,p=1,x[sa[0]]=0,i=1;i<n;i++)
x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;
}
return;
}

int main()
{
int a;
a = 2;
char s[1000],l;
int r[1000],sa[1000],i;
while(scanf("%s",s) == 1)
{
puts(s);
l = strlen(s);   l++;

for(i=0; i<l-1; i++) r[i] = s[i]-'a'+1;
r[l-1] = 0;

da(r,sa,l,27);

//------------------------------------------
for(i=0; i<l-1; i++)  // rank[i] : suffix(i)排第几
printf("rank[%d] =  %d\n",i,rank[i]);
printf("\n");
for(i=0; i<l; i++)   // sa[i] : 排在第i个的是谁
printf("sa[%d] =  %d\n",i,sa[i]);
//------------------------------------------
}
return 0;
}