2012杭州网络赛

Arrest

费用流。

将每个有敌人的城市拆开，之间连一条容量为1，费用为-inf的边，表示逮捕，保证最后所有敌人被抓到。

源点到起点连一条容量为K，费用为0的边，表示出动K个小分队。

起点到汇点连容量为inf，费用为0的边，表示小分队可以不动，无费用产生。

接着所有城市跑一遍floyd，i<j时连一条edge(i',j,f,w)，i'是拆开的点，容量为inf，费用为distance(i,j)。

起点到各个城市i连一条容量为inf，费用为distance(0,i)的边。

i'到汇点连一条容量为inf，费用为0点，表示结束。

跑一遍费用流就可以了。

/*==================================================*\
| 最小费用流 O(V * E * f)
| INIT: network g; g.build(v);
| CALL: g.mincost(s, t); flow=g.flow; cost=g.cost;
| 注意: SPFA增广, 实际复杂度远远小于O(V * E);
\*==================================================*/
#include <stdio.h>
#include <string.h>
#define typef int // type of flow
#define typec int // type of dis
#define min(x,y) (x<y?x:y)
const typef inff = 0x000fffff; // max of flow
const typec infc = 0x000fffff; // max of dis
const int N=350;
const int E=N*N;
struct network
{
    int nv, ne, pnt[E], nxt[E];
    int vis[N], que[N], head[N], pv[N], pe[N];
    typef flow, cap[E]; typec cost, dis[E], d[N];
    void addedge(int u, int v, typef c, typec w) {
        pnt[ne] = v; cap[ne] = c;
        dis[ne] = +w; nxt[ne] = head[u]; head[u] = (ne++);
        pnt[ne] = u; cap[ne] = 0;
        dis[ne] = -w; nxt[ne] = head[v]; head[v] = (ne++);
    }
    int mincost(int src, int sink) {
        int i, k, f, r; typef mxf;
        for (flow = 0, cost = 0; ; ) {
            memset(pv, -1, sizeof(pv));
            memset(vis, 0, sizeof(vis));
            for (i = 0; i < nv; ++i) d[i] = infc;
            d[src] = 0; pv[src] = src; vis[src] = 1;
            for (f = 0, r = 1, que[0] = src; r != f; ) {
                i = que[f++]; vis[i] = 0;
                if (N == f) f = 0;
                for (k = head[i]; k != -1; k = nxt[k])
                    if(cap[k] && dis[k]+d[i] < d[pnt[k]])
                    {
                        d[pnt[k]] = dis[k] + d[i];
                        if (0 == vis[pnt[k]]) {
                        vis[pnt[k]] = 1;
                        que[r++] = pnt[k];
                        if (N == r) r = 0;
                        }
                        pv[pnt[k]]=i; pe[pnt[k]]=k;
                    }
            }
            if (-1 == pv[sink]) break;

            for (k = sink, mxf = inff; k != src; k = pv[k])
                if (cap[pe[k]] < mxf) mxf = cap[pe[k]];
            flow += mxf; cost += d[sink] * mxf;
            for (k = sink; k != src; k = pv[k]) {
                cap[pe[k]] -= mxf; cap[pe[k] ^ 1] += mxf;
            }
        }
        return cost;
    }
    void build(int v) {
        nv = v; ne = 0;
        memset(head, -1, sizeof(head));
        /*
        int x, y; typef f; typec w;
        for (int i = 0; i < e; ++i) {
            cin >> x >> y >> f >> w; // vertex: 0 ~ n-1
            addedge(x, y, f, w);// add arc (u->v, f, w)
        }*/
    }
} g;
int f[N][N];
int main()
{
    int n,m,K,i,j,s,t,k;
    while ( scanf("%d %d %d",&n,&m,&K),!(n==0&&m==0&&K==0) )
    {
        //init
        g.build(2*n+4);
        for (i=0; i<=n; i++)
          for (j=0; j<=n; j++)
            f[i][j]=inff;
        //input
        for (i=1; i<=m; i++){
            scanf("%d %d %d", &s, &t, &k);
            f[s][t]=min(f[s][t],k);
            f[t][s]=min(f[t][s],k);
        }
        //floyd
        for (k=0; k<=n; k++)
          for (i=0; i<=n; i++)
            for (j=0; j<=n; j++)
              f[i][j]=min(f[i][j],f[i][k]+f[k][j]);
        //build {s=2n+1, t=2n+2}
        g.addedge(2*n+1,0,K,0);
        for (i=1; i<=n; i++) g.addedge(0,i,inff,f[0][i]);
        g.addedge(0,2*n+2,inff,0);
        for (i=1; i<=n; i++) {
            g.addedge(i,i+n,1,-inff);
            g.addedge(i+n,2*n+2,inff,f[i][0]);
        }
        for (i=1; i<n; i++)
          for (j=i+1; j<=n; j++)
          {
              g.addedge(i+n,j,inff,f[i][j]);
          }
        g.mincost(2*n+1,2*n+2);
        printf("%d\n",g.cost+inff*n);
    }

    return 0;
}

 

Good Article Good sentence

居然调戏zengxiaoxian。。。

用{A}表示A的所有子串的集合，这题就是求{A}-{B}。

在数学上{A}-{B}={AUB}-{B}={AUB-B}

那么就是求{AUB}中不同子串的个数减去{B}中不同子串的个数。变成模板题了。用SA搞搞，用SAM超时了。T T

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
typedef __int64 ll;
#define min(x,y) ( (x)<(y)?(x):(y) )
#define max(x,y) ( (x)<(y)?(y):(x) )
const int N=311000;
//call makesa(); lcp();
char *s,sbuff[N];
int n, sa[4*N], rank[N], height[N];
int buf[4*N], ct[N], sx[N], sax[N];
inline bool leq(int a, int b, int x, int y)
{ return ( (a < x) || (a == x && b <= y) ); }
inline bool leq(int a, int b, int c, int x, int y, int z)
{ return ( (a < x) || (a == x && leq(b, c, y, z))); }
inline int geti(int t, int nx, int sa[])
{ return ( sa[t]<nx ? sa[t]*3+1 : (sa[t]-nx)*3+2); }
static void radix(int a[], int b[], int s[], int n, int k)
{ // sort a[0..n-1] to b[0..n-1] with keys in 0..k from s
int i, t, sum;
memset(ct, 0, (k + 1) * sizeof(int));
for (i = 0; i < n; ++i) ct[s[a[i]]]++;
for (i = 0, sum = 0; i <= k; ++i) {
t = ct[i]; ct[i] = sum; sum += t;
}
for (i = 0; i < n; i++) b[ct[s[a[i]]]++] = a[i];
}
void suffix(int s[], int sa[], int n, int k)
{ // !!! require s[n] = s[n+1] = s[n+2] = 0, n >= 2.
int i, j, e, p, t;
int name = 0, cx = -1, cy = -1, cz = -1;
int nx = (n+2)/3, ny = (n+1)/3, nz = n/3, nxz = nx+nz;
int *syz = s + n + 3, *sayz = sa + n + 3;
for (i=0, j=0; i < n + (nx - ny); i++)
if (i%3 != 0) syz[j++] = i;
radix(syz , sayz, s+2, nxz, k);
radix(sayz, syz , s+1, nxz, k);
radix(syz , sayz, s , nxz, k);
for (i = 0; i < nxz; i++) {
if (s[ sayz[i] ] != cx || s[ sayz[i] + 1 ] != cy ||
s[ sayz[i] + 2 ] != cz) {
name++; cx = s[ sayz[i] ];
cy = s[ sayz[i] + 1 ]; cz = s[ sayz[i] + 2 ];
}
if (sayz[i] % 3 == 1) syz[ sayz[i] / 3 ] = name;
else syz[ sayz[i]/3 + nx ] = name;
}
if (name < nxz) {
suffix(syz, sayz, nxz, name);
for (i = 0; i < nxz; i++) syz[sayz[i]] = i + 1;
} else {
for (i = 0; i < nxz; i++) sayz[syz[i] - 1] = i;
}
for (i = j = 0; i < nxz; i++)
if (sayz[i] < nx) sx[j++] = 3 * sayz[i];
radix(sx, sax, s, nx, k);
for (p=0, t=nx-ny, e=0; e < n; e++) {
i = geti(t, nx, sayz); j = sax[p];
if ( sayz[t] < nx ?
leq(s[i], syz[sayz[t]+nx], s[j], syz[j/3]) :
leq(s[i], s[i+1], syz[sayz[t]-nx+1],
s[j], s[j+1], syz[j/3+nx]) ) {
sa[e] = i;
if (++t == nxz) {
for (e++; p < nx; p++, e++)
sa[e] = sax[p];
}
}
else {
sa[e] = j;
if (++p == nx) for (++e; t < nxz; ++t, ++e)
sa[e] = geti(t, nx, sayz);
}
}
}
void makesa(){
memset(buf, 0, 4 * n * sizeof(int));
memset(sa, 0, 4 * n * sizeof(int));
for (int i=0; i<n; ++i) buf[i] = s[i] & 0xff;
suffix(buf, sa, n, 255);
for (int i=0; i<n; i++) rank[ sa[i] ]=i;
}
void lcp(){ // O(4 * N)
int i, j, k;
for (j = rank[height[i=k=0]=0]; i < n - 1; i++, k++)
while (k >= 0 && s[i] != s[ sa[j-1] + k ])
height[j] = (k--), j = rank[ sa[j] + 1 ];
}
int len,flg[N];
ll getsum()
{
    int i,t=0,cnt=0,j=0;
    ll ret=0;
    for (i=0; i<n; i++){
        if (s[i]=='$'){
            for (; j<=i; j++) flg[j]=i;
        }
        cnt++;
    }
    for (i=1; i<n; i++)
    {
        if ( s[sa[i]]<'a'||s[sa[i]]>'z' ) continue;
        t=flg[ sa[i] ]-(height[i]+sa[i]);
        if (t>0) {
            //printf("i=%d s=%s t=%d\n",i,s+sa[i],t);
            ret+=t;
        }
    }
    //printf("str=%s  substrcnt=%I64d\n",s,ret);
    //for (i=0; i<n; i++) printf("%d ",flg[i]);puts("");
    return ret;
}
//输入一些字符串，用$分开，求出不同的子串个数
//call makesa();lcp();getsum();
//s=sbuff,n=strlen(s)+1;
int main()
{
    int m,i,cas=0,len,T,zxx;
    ll x,y;
    char *sp;
    scanf("%d",&T);
    while ( T-- )
    {
        s=sbuff;
        memset(flg,0,sizeof(flg));
        scanf("%d",&m);
        scanf("%s",s);
        n=strlen(s)+1;
        zxx=n-1;
        s[n-1]='$';
        s[n]=0;
        sp=s+n;
        for (i=0; i<m; i++)
        {
            scanf("%s",sp);
            len=strlen(sp);
            sp+=len;
            *(sp++)='$';
        }
        *sp=0;
        s=sbuff;
        n=strlen(s)+1;
        makesa();
        lcp();
        y=getsum();
        s=sbuff+zxx+1;
        n=strlen(s)+1;
        makesa();
        lcp();
        x=getsum();
        printf("Case %d: %I64d\n",++cas,(y-x));
    }
    return 0;
}

Finding crosses

模拟题，随便搞搞就好了。

#include <stdio.h>
#include <string.h>
#define NN 60
int n;
char s[NN][NN];//图
int  vis[NN*NN];
int  sum[NN*NN];
int  id[NN][NN];//记录连通块id
int  hang[NN*NN],lie[NN*NN];
void dfs(int i, int j, int c)
{
    if (i<0||j<0||i>=n||j>=n||id[i][j]!=0) return ;
    else
    if (s[i][j]=='#')
    {
        id[i][j]=c;
        dfs(i+1,j+0,c);
        dfs(i+0,j+1,c);
        dfs(i-1,j+0,c);
        dfs(i+0,j-1,c);
    }

}
int judge(int x, int y, int len)
{
    int i,j,k,sum=0;
    i=x,j=y;
    //j不动
    while (s[i][j]=='#' && i<n) { sum++;i++; }
    if (sum!=len) return 0;

    i=x+len/2,j=y-len/2,sum=0;
    if ( i>=n || j<0 ) return 0;
    //i不动
    while (s[i][j]=='#' && j<n) { sum++;j++; }
 //   printf("sum=%d\n",sum);
    if (sum!=len) return 0;
    return 1;
}
void init()
{
        memset(vis,0,sizeof(vis));
        memset(sum,0,sizeof(sum));
        memset(id,0,sizeof(id));
        memset(hang,0,sizeof(hang));
        memset(lie,0,sizeof(lie));
}
int main()
{
    int T,i,j,k,count,csum;
    while ( scanf("%d",&n),n )
    {
        init();
        csum=count=0;
        for (i=0; i<n; i++)
          scanf("%s",s[i]);
        for (i=0; i<n; i++)
          for (j=0; j<n; j++)
          {
              if (s[i][j]=='#' && id[i][j]==0)
              {
//                  printf("%d %d\n",i,j);
                  dfs(i,j,++count);
              }
          }
        for (i=0; i<n; i++)
          for (j=0; j<n; j++)
            sum[ id[i][j] ]++;

        for (i=1;i<=count;i++)
            if ( sum[i]>=5 && (sum[i]-1)%4==0 ) vis[i]=1;

        for (i=0; i<n; i++)
          for (j=0; j<n; j++)
            if ( vis[ id[i][j] ] !=0 )
            {
                csum+=judge(i,j, (sum[ id[i][j] ]+1)/2 );
                vis[ id[i][j] ]=0;

            }
        printf("%d\n",csum);
    }



    return 0;
}

Super Mario

先把输入按照高度给排序了。然后按照高度递增完成insert和query。太久了，大概就是这个思路。开始要查询某区间小于H的个数，转化为按H递增用BIT求区间和。太久了，直接贴代码。

//Binary Indexed Trees\//poj2182
//call BIT s;
//call s.init(n); n为区间长度。
//call s.add(i,v);
//call s.sum(i),sum of a[1..i]; call s.sum(x,y),sum of a[x..y];
#include <cstdio>
#include <string.h>
#include <algorithm>
using namespace std;
#define lowbit(x) ((x) & (-x))
typedef int typev;  //type of res
static const int N=100100;   //max size
struct BIT{
  typev ar[N];      //index 1..N-1
  int n;
  void init(int nn){
    memset(ar,0,sizeof(ar));
    n=nn+1;
  }
  void add(int i, typev v){
    for ( ; i<n; ar[i]+=v, i+=lowbit(i) );
  }
  typev sum(int i){
    typev s=0;
    for ( ; i>0; s+=ar[i], i-=lowbit(i) );
    return s;
  }
  typev sum(int x, int y){
    return (sum(y)-sum(x-1));
  }
}s;
//EOF
struct _node{int x,y,k,id,ans;}a[N];
struct _len{int k,x;}l[N];
inline bool cmp1(const _node &a, const _node &b){return (a.k<b.k);}
inline bool cmp2(const _node &a, const _node &b){return (a.id<b.id);}
inline bool cmp3(const _len &a, const _len &b){return (a.k<b.k);}
void work(int n, int m){
    int i=0,j=0;
    while (i<n && j<m)
    {
        while (i<n&&l[i].k<=a[j].k) {
            s.add(l[i++].x,1);
        }
        while (j<m&&i<n&&l[i].k>a[j].k){
            a[j].ans=s.sum(a[j].x,a[j].y);
            j++;
        }
    }
    while (j<m){
        a[j].ans=s.sum(a[j].x,a[j].y);
        j++;
    }
}
int main(){
    int n,m,i,cas=0,T;
    scanf("%d",&T);
    while (T--){
        scanf("%d %d", &n, &m);
        s.init(n+10);
        for (i=0; i<n; i++){
            scanf("%d",&l[i].k);
            l[i].x=i+1;
        }
        for (i=0; i<m; i++) {
            scanf("%d %d %d", &a[i].x, &a[i].y, &a[i].k);
            a[i].x++,a[i].y++;
            a[i].id=i;
        }
        sort(l,l+n,cmp3);
        sort(a,a+m,cmp1);
        work(n,m);
        sort(a,a+m,cmp2);

        printf("Case %d:\n",++cas);
        for (i=0; i<m; i++)
        {
            printf("%d\n",a[i].ans);
        }

    }

    return 0;
}