FOJ有奖月赛-2015年03月 题解

月赛链接：http://acm.fzu.edu.cn/contest/index.php?cid=141

神牛题解：http://blog.csdn.net/accelerator_/article/details/44564417

本题解是参照楼上神牛题解编出来的（最后一题完全抄袭了~

前面打星的是和神牛思路不同的

*A:由于字符串长 < 1000所以可以展开第一个串，每次展开长度用第二个串长限制就好了，然后跑KMP

B:树状数组大法好

*C:首先思考对于最少化路径的障碍是什么，xeryj是分叉，那么考虑如何高效的消除树叶。第一问：贪心，一条路径最多消灭两个叶子。第二问：想象从树的边缘开始对分叉两两合并，最后还有一个长条，这样贪心一定是最优的。

D:求任意两个宝藏直接的最短路（小明也看做宝藏），得到一个11*11的图，可以想到状态压缩搞，但是有回路，需要多出一维保存当前到了什么位置（完整的状态定义是 小明去的第一个宝藏+小明走过宝藏的集合+小明现在所在的宝藏，只用后两个就可以了，这样就等价于穷举小明去的第一个宝藏取最小的保存在状态数组里），还是不明白可以看货郎担问题（旅行商问题）的dp解法，需要注意的一点是:如果小明的位置是墙，直接输出-1

E、扫描线线段树

F、定义好状态bfs搜最短路就好了，就是判的有点多，两岸船上都要判断

G、这一发说实话没搞明白。。。能想到小数据暴力，大数据贪心，但是没法证明。。。。

/*
 * Problem:  FOJ 2183
 * Author:  SHJWUDP
 * Created Time:  2015/3/23 星期一 14:36:33
 * File Name: 233.cpp
 * State: Accepted
 * Memo: BF KMP
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int MaxA=1e3+7;
const int MaxB=1e6+7;

char cs[MaxA], ns[MaxA];
char str[MaxB];
int nt[MaxB];
int lc, ln, len;
void getFail(char* P, int* f) {
    int m=strlen(P);
    f[0]=0; f[1]=0;
    for(int i=1; i<m; i++) {
        int j=f[i];
        while(j && P[i]!=P[j]) j=f[j];
        f[i+1]=P[i]==P[j]?j+1:0;
    }
}
bool find(char* T, char* P, int* f) {
    int n=strlen(T), m=strlen(P);
    getFail(P, f);
    int j=0;
    for(int i=0; i<n; i++) {
        while(j && P[j]!=T[i]) j=f[j];
        if(P[j]==T[i]) j++;
        if(j==m) return true;
    }
    return false;
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    while(~scanf("%s%s", cs, ns)) {
        lc=strlen(cs); ln=strlen(ns);
        len=0;
        for(int i=0; i<lc; i++) {
            if('a'<=cs[i] && cs[i]<='z') {
                str[len++]=cs[i];
            } else {
                int tmp=0;
                i++;
                while(cs[i]!=']') {
                    tmp=tmp*10+cs[i++]-'0';
                }
                tmp=min(tmp, ln);
                while(--tmp) {
                    str[len]=str[len-1];
                    len++;
                }
            }
        }
        str[len]=0;
        if(find(str, ns, nt)) printf("True
");
        else printf("False
");
    }
    return 0;
}

/*
 * Problem: FOJ 2185 逆序数还原 
 * Author:  SHJWUDP
 * Created Time:  2015/3/25 星期三 23:06:56
 * File Name: 233.cpp
 * State: Accepted
 * Memo: Fenwick
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int MaxA=1e3+7;

struct Fenwick {
    int n;
    int c[MaxA];

    void init(int n) {
        this->n=n;
        memset(c, 0, sizeof(c[0])*(n+3));
    }

    int lowbit(int x) {
        return x&-x;
    }

    void update(int x, int v) {
        for(int i=x; i<=n; i+=lowbit(i)) c[i]+=v;
    }

    int query(int x) {
        int res=0;
        for(int i=x; i>0; i-=lowbit(i)) res+=c[i];
        return res;
    }
} fw;

int N;
int find(int x) {
    int l=1, r=N+1, m;
    while(l<r) {
        m=(l+r)>>1;
        if(fw.query(m)>x) r=m;
        else l=m+1;
    }
    return l;
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    while(~scanf("%d", &N)) {
        fw.init(N+1);
        for(int i=1; i<=N; i++) {
            fw.update(i, 1);
        }

        for(int i=0; i<N; i++) {
            int x;
            scanf("%d", &x);
            int tmp=find(x);
            printf("%d%c", tmp, " 
"[i==N-1]);
            fw.update(tmp, -1);
        }
    }
    return 0;
}

/*
 * Problem: FOJ 2185 树的路径覆盖
 * Author:  SHJWUDP
 * Created Time:  2015/3/24 星期二 09:25:45
 * File Name: 233.cpp
 * State: Accepted
 * Memo: greedy
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int MaxA=1e5+7;

int n;
int dg[MaxA];
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    int T;
    scanf("%d", &T);
    while(T--) {
        scanf("%d", &n);
        if(n==1) {
            printf("0 0
");
            continue;
        }
        memset(dg, 0, sizeof(dg));
        for(int i=1; i<n; i++) {
            int x;
            scanf("%d", &x);
            dg[i]++;
            dg[x]++;
        }
        int cnt=0, ans2=0;
        for(int i=0; i<n; i++) {
            if(dg[i]==1) cnt++;
            else ans2+=(dg[i]-1)>>1;
        }
        printf("%d %d
", (cnt>>1)+(cnt&1), ans2+1);
    }
    return 0;
}

/*
 * Problem: FOJ 2186 小明的迷宫
 * Author:  SHJWUDP
 * Created Time:  2015/3/24 星期二 12:30:09
 * File Name: 233.cpp
 * State: Accepted
 * Memo: bfs dp
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

const int MaxA=100+7;
const int MaxB=11+7;
const int MaxC=MaxA*MaxA;

struct Point {
    int x, y;
    Point() {}
    Point(int x, int y):x(x), y(y) {}
} p[MaxB];

int n, m;
int grid[MaxA][MaxA];    //original graph
int id;                    //宝藏编号
int dir[][2]={{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int x[MaxC], y[MaxC], dist[MaxC];
int vis[MaxA][MaxA];

int G[MaxB][MaxB];
int f[MaxB][(1<<10)+7];    //f[当前位置][已遍历集合]
int super;    //最终态
int ans;
inline bool inlaw(int x, int y) {
    if(x>=0 && x<n && y>=0 && y<m
            && grid[x][y]>=0
            && !vis[x][y]) 
        return true;
    else return false;
}
bool bfs(int st) {        //如果宝藏不联通，返回false
    memset(vis, 0, sizeof(vis));
    int f=0, r=1;
    x[f]=p[st].x; y[f]=p[st].y;
    vis[x[f]][y[f]]=1;
    int cnt=0;
    while(f!=r) {
        for(int k=0; k<4; k++) {
            x[r]=x[f]+dir[k][0];
            y[r]=y[f]+dir[k][1];
            if(inlaw(x[r], y[r])) {
                vis[x[r]][y[r]]=1;
                if(grid[x[r]][y[r]]>0) {
                    G[st][grid[x[r]][y[r]]]=dist[f]+1;
                    cnt++;
                }
                dist[r++]=dist[f]+1;
            }
        }
        f++;
    }
    if(cnt!=id-1) return false;
    return true;
}
void dp(int u, int sta) {
    if(sta==super) {
        ans=min(ans, f[u][sta]+G[u][1]);
        return ;
    }
    for(int i=2; i<=id; i++) {
        int k=i-2;
        if(!(sta & (1<<k))
                && f[i][sta|(1<<k)]>f[u][sta]+G[u][i]) {
            f[i][sta|(1<<k)]=f[u][sta]+G[u][i];
            dp(i, sta|(1<<k));
        }
    }
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    while(~scanf("%d%d", &n, &m)) {
        id=1;    //小明是一号宝藏
        for(int i=0; i<n; i++) {
            for(int j=0; j<m; j++) {
                scanf("%d", &grid[i][j]);
                if((i||j) && grid[i][j]>0) {
                    grid[i][j]=++id;
                    p[id]=Point(i, j);
                }
            }
        }
        if(grid[0][0]<0) {    //这里有个坑，小明的位置是墙的话直接 -1
            printf("-1
");
            continue;
        }
        p[grid[0][0]=1]=Point(0, 0);

        memset(G, 0, sizeof(G));
        bool ok=true;
        for(int i=1; i<=id && ok; i++) {
            ok=bfs(i);
        }
        if(!ok) {
            printf("-1
");
            continue;
        }

        memset(f, 0x7f, sizeof(f));
        super=(1<<(id-1))-1;
        f[1][0]=0;    //初始位置代价为0
        ans=0x7fffffff;
        dp(1, 0);
        printf("%d
", ans);
    }
    return 0;
}

/*
 * Problem: FOJ 2187 回家种地 
 * Author:  SHJWUDP
 * Created Time:  2015/3/24 星期二 19:47:35
 * File Name: 233.cpp
 * State: Accepted
 * Memo: segmentTree
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long LL;

const int MaxA=1e5+7;

struct Segment {
    int l, r, h, v;
    Segment() {}
    Segment(int l, int r, int h, int v):l(l), r(r), h(h), v(v) {}

    bool operator<(const Segment& x) const {
        return this->h < x.h;
    }
} seg[MaxA<<1];

struct SegmentTree {
    struct STNode {
    //len 0：未覆盖区域长度 1：覆盖一次区域长度 2:覆盖多次区域长度
        int cov, len[3];    
    } *c;
    int n;
    int L, R, v;
    int* X;

#define lson l, m, rt<<1
#define rson m+1, r, rt<<1|1

    SegmentTree(int n, int* X) {
        this->n=n; this->X=X;
        c=new STNode[n<<2];
        build(0, n-1, 1);
    }
    ~SegmentTree() {
        delete c;
    }


    void build(int l, int r, int rt) {
        c[rt].cov=0;
        memset(c[rt].len, 0, sizeof(c[rt].len));
        c[rt].len[0]=X[r+1]-X[l];
        if(l==r) return ;
        int m=(l+r)>>1;
        build(lson);
        build(rson);
    }

    void pushUp(int l, int r, int rt) {
        memset(c[rt].len, 0, sizeof(c[rt].len));
        if(l==r) {
            c[rt].len[min(2, c[rt].cov)]=X[r+1]-X[l];
        } else {
            for(int i=0; i<=2; i++) {
                c[rt].len[min(2, c[rt].cov+i)]+=c[rt<<1].len[i]+c[rt<<1|1].len[i];
            }
        }
    }

    void doUpdate(int l, int r, int rt) {
        if(L<=l && r<=R) {
            c[rt].cov+=v;
            pushUp(l, r, rt);
            return ;
        }
        int m=(l+r)>>1;
        if(L<=m) doUpdate(lson);
        if(m<R) doUpdate(rson);
        pushUp(l, r, rt);
    }

    void update(int L, int R, int v) {
        this->L=L; this->R=R; this->v=v;
        doUpdate(0, n-1, 1);
    }
#undef lson
#undef rson
};

int n;
int table[MaxA<<1];

template<class T>
int bin(T* ll, T* rr, const T& x) {
    return lower_bound(ll, rr, x)-ll;
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    int T, now=0;
    scanf("%d", &T);
    while(T--) {
        scanf("%d", &n);
        int sn=0, tn=0;
        for(int i=0; i<n; i++) {
            int x1, x2, y1, y2;
            scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
            seg[sn++]=Segment(x1, x2, y1, 1);
            seg[sn++]=Segment(x1, x2, y2, -1);
            table[tn++]=x1;
            table[tn++]=x2;
        }
        sort(seg, seg+sn);
        sort(table, table+tn);
        tn=unique(table, table+tn)-table;

        SegmentTree st(tn, table);
        LL ans=0;
        for(int i=0, lim=sn-1; i<lim; i++) {
            int l=bin(table, table+tn, seg[i].l);
            int r=bin(table, table+tn, seg[i].r)-1;
            if(l<=r) st.update(l, r, seg[i].v);
            ans+=LL(seg[i+1].h-seg[i].h)*st.c[1].len[1];
        }
        printf("Case %d: %I64d
", ++now, ans);
    }
    return 0;
}

/*
 * Problem:  FOJ 2188 过河I
 * Author:  SHJWUDP
 * Created Time:  2015/3/25 星期三 10:02:28
 * File Name: 233.cpp
 * State: Accepted
 * Memo: dp
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

const int MaxA=200+7;

struct State {
    int x, y, sign, dep;
    State(int x, int y, int s, int d):x(x), y(y), sign(s), dep(d) {}
};

int x, y, n;
int f[MaxA][MaxA][2];
void insert(queue<State>& Q, const State& u, int a, int b) {
    int lx, ly, rx, ry;
    if(u.sign==0) {
        lx=u.x-a; ly=u.y-b;
        rx=(x-u.x)+a; ry=(y-u.y)+b;
    } else {
        lx=u.x+a; ly=u.y+b;
        rx=(x-u.x)-a; ry=(y-u.y)-b;
    }
    //if(lx<0 || ly<0 || rx<0 || ry<0) return ;
    if((lx>=ly || lx==0)
            && (rx>=ry || rx==0)
            && f[lx][ly][u.sign^1]>f[u.x][u.y][u.sign]+1) {
        f[lx][ly][u.sign^1]=f[u.x][u.y][u.sign]+1;
        Q.push(State(lx, ly, u.sign^1, u.dep+1));
    }
}
int bfs() {
    memset(f, 0x7f, sizeof(f));
    f[x][y][0]=0;
    queue<State> Q;
    Q.push(State(x, y, 0, 0));
    while(!Q.empty()) {
        State u=Q.front(); Q.pop();
        if(!u.x && !u.y && u.sign) return u.dep;
        for(int i=1, lim1=min(n, u.sign?x-u.x:u.x); i<=lim1; i++) {
            for(int j=0, lim2=min(n-i, min(i, u.sign?y-u.y:u.y)); j<=lim2; j++) {
                insert(Q, u, i, j);
            }
        }
        for(int j=1, lim=min(n, u.sign?y-u.y:u.y); j<=lim; j++) {
            insert(Q, u, 0, j);
        }
    }
    return -1;
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    while(~scanf("%d%d%d", &x, &y, &n)) {
        printf("%d
", bfs());
    }
    return 0;
}

/*
 * Problem:  FOJ 2189 过河II
 * Author:  SHJWUDP
 * Created Time:  2015/3/25 星期三 19:10:27
 * File Name: 233.cpp
 * State: Accepted
 * Memo: greedy+dp
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

const int MaxA=21;

struct State {
    int x, y, sign, dep;
    State(int x, int y, int s, int d):x(x), y(y), sign(s), dep(d) {}
};

int m, n;
int f[MaxA][MaxA][2];
void insert(queue<State>& Q, const State& u, int a, int b) {
    int lx, ly, rx, ry;
    if(u.sign==0) {
        lx=u.x-a; ly=u.y-b;
        rx=(m-u.x)+a; ry=(m-u.y)+b;
    } else {
        lx=u.x+a; ly=u.y+b;
        rx=(m-u.x)-a; ry=(m-u.y)-b;
    }
    if((lx>=ly || !lx)
            && (rx>=ry || !rx)
            && f[lx][ly][u.sign^1]>f[u.x][u.y][u.sign]+1) {
        f[lx][ly][u.sign^1]=f[u.x][u.y][u.sign]+1;
        Q.push(State(lx, ly, u.sign^1, u.dep+1));
    }
}
int bfs() {
    if(m>20) return -1;
    memset(f, 0x7f, sizeof(f));
    f[m][m][0]=0;
    queue<State> Q;
    Q.push(State(m, m, 0, 0));
    while(!Q.empty()) {
        State u=Q.front(); Q.pop();
        if(!u.x && !u.y && u.sign) return u.dep;
        for(int i=1, lim1=min(n, u.sign?m-u.x:u.x); i<=lim1; i++) {
            for(int j=0, lim2=min(n-i, min(i, u.sign?m-u.y:u.y)); j<=lim2; j++){
                insert(Q, u, i, j);
            }
        }
        for(int j=1, lim=min(n, u.sign?m-u.y:u.y); j<=lim; j++) {
            insert(Q, u, 0, j);
        }
    }
    return -1;
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    while(~scanf("%d%d", &m, &n)) {
        int ans;
        if(n<4) {
            ans=bfs();
        } else {
            ans=0;
            int x=(n>>1)-1;
            while(m-x>n) {
                m-=x;
                ans+=2;
            }
            if(m>n && (n&1) && n>=m-(n>>1)) {
                ans+=5;
            } else {
                while(m>n) {
                    m-=x;
                    ans+=2;
                }
                if((m<<1)<=n) ans++;
                else if(m==n) ans+=5;
                else ans+=3;
            }
        }
        printf("%d
", ans);
    }
    return 0;
}