2014 ACM/ICPC Asia Regional Xi'an Online

Post Robot http://acm.hdu.edu.cn/showproblem.php?pid=5007

字符串比较

#include<cstdio>
char a[110];
char A[]="MAI MAI MAI!";
char B[]="SONY DAFA IS GOOD!";
char apple[4][8]={"Apple","iPhone","iPod","iPad"};
char sony[]="Sony";
bool judge(char my[],int s){
    for(int i=0;my[i];i++){
        if(my[i]!=a[s+i]) return false;
    }
    return true;
}
int main(){
    while(gets(a)){
        for(int i=0;a[i];i++){
            if(judge(sony,i)){
                puts(B);
                continue;
            }
            for(int j=0;j<4;j++){
                if(judge(apple[j],i)){
                    puts(A);
                    break;
                }
            }
        }
    }
    return 0;
}

Boring String Problem http://acm.hdu.edu.cn/showproblem.php?pid=5008

先后缀数组，然后遍历处理出前几个后缀能构成的不同字串，存sum中。然后找第k个的时候二分sum，就知道第k个在第几个后缀中。然后能构成这个串的不一定只有一个，只要字典序大的那些前缀够长，也不是没有可能嘛。所以要往下找一个区间，区间内的height要大于等于这个串的长度，height是公共前缀长度。然后对这个区间求最小的sa。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
typedef __int64 LL;
const int M=100010;
class Range_Maximum_Query{///区间最值查询离线算法init_o(nlogn),query_o(1)
    int LOG[M],dpmax[M][20],dpmin[M][20];
public:
    void init(){///使用类前调用一次即可
        LOG[0]=-1;
        for(int i=1;i<M;i++){
            LOG[i]=LOG[i>>1]+1;
        }
    }
    void Make_RMQ(int n,int a[]){///传入点的个数，下标1开始
        for(int i=1;i<=n;i++){
            dpmax[i][0]=dpmin[i][0]=a[i];
        }
        for(int j=1;j<=LOG[n];j++){
            for(int i=1;i+(1<<j)-1<=n;i++){
                dpmax[i][j]=max(dpmax[i][j-1],dpmax[i+(1<<(j-1))][j-1]);
                dpmin[i][j]=min(dpmin[i][j-1],dpmin[i+(1<<(j-1))][j-1]);
            }
        }
    }
    int get_RMQ(int a,int b,bool big){///传入1返回max，传入0返回min
        int k=LOG[b-a+1];
        if(big)
        return max(dpmax[a][k],dpmax[b-(1<<k)+1][k]);
        return min(dpmin[a][k],dpmin[b-(1<<k)+1][k]);
    }
}rmqsa,rmqheight;
class Suffix_Array {  ///后缀数组
    static const int MV=M;///串长度
public:
    int n,m,i,j,k,p,str[MV],sa[MV],height[MV],Rank[MV],wa[MV],wb[MV],wv[MV],ws[MV];///sa按字典序排序后后缀下标，rank后缀的排名，height排名相邻两个后缀的最长公共前缀
    bool cmp(int r[],int a,int b,int len) {
        return r[a]==r[b]&&r[a+len]==r[b+len];
    }
    void buildsa() {
        int *x=wa,*y=wb;
        for(i=0; i<m; i++) ws[i]=0;
        for(i=0; i<n; i++) ws[x[i]=str[i]]++;
        for(i=1; i<m; i++) ws[i]+=ws[i-1];
        for(i=n-1; i>=0; i--) sa[--ws[x[i]]]=i;
        for(j=p=1; p<n; j<<=1,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<m; i++) ws[i]=0;
            for(i=0; i<n; i++) ws[wv[i]=x[y[i]]]++;
            for(i=1; i<m; i++) ws[i]+=ws[i-1];
            for(i=n-1; i>=0; i--) sa[--ws[wv[i]]]=y[i];
            for(swap(x,y),x[sa[0]]=0,p=i=1; i<n; i++) x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;
        }
    }
    void buildheight() {
        for(i=1; i<=n-1; i++) Rank[sa[i]]=i;
        for(i=k=0; i<n-1; height[Rank[i++]]=k)
            for(k?k--:0,j=sa[Rank[i]-1]; str[i+k]==str[j+k]; k++);
    }
    int getsa(int id) {
        return sa[id];
    }
    int getheight(int id) {
        return height[id];
    }
    int getrank(int id) {
        return Rank[id];
    }
    void build(char s[],int len,int cl) {///n为字符串长度加一,m为最大字符值加一
        n=len;
        m=cl;
        for(int i=0; i<=len; i++) str[i]=s[i];
        str[len]=0;
        buildsa();
        buildheight();
    }
} gx;
char a[M];
LL sum[M];
int main(){
    rmqsa.init();
    rmqheight.init();
    while(~scanf("%s",a)){
        int n=strlen(a);
        gx.build(a,n+1,256);
        rmqsa.Make_RMQ(n,gx.sa);
        rmqheight.Make_RMQ(n,gx.height);
        LL tmp;
        sum[0]=0;
        for(int i=1;i<=n;i++){
            tmp=n-gx.getsa(i)-gx.getheight(i);
            sum[i]=sum[i-1]+tmp;
        }
        int q;
        LL v,l=0,r=0;
        scanf("%d",&q);
        while(q--){
            scanf("%I64d",&v);
            LL k=(l^r^v)+1;
            if(k>sum[n]){
                l=r=0;
                puts("0 0");
                continue;
            }
            int id=lower_bound(sum,sum+n,k)-sum;
            l=gx.getsa(id);
            r=n-1;
            LL cha=sum[id]-k;
            r-=cha;
            int len=r-l+1;
            int L=id+1,R=n;
            int to=id;
            while(L<=R){
                int mid=(L+R)>>1;
                if(rmqheight.get_RMQ(id+1,mid,0)>=len){
                    to=max(to,mid);
                    L=mid+1;
                }
                else{
                    R=mid-1;
                }
            }
            l=rmqsa.get_RMQ(id,to,0);
            r=l+len-1;
            l++;
            r++;
            printf("%I64d %I64d
",l,r);
        }
    }
    return 0;
}

Game http://acm.hdu.edu.cn/showproblem.php?pid=5011

用的是尼姆博弈的结论，至于为什么和原来的尼姆博弈的结论是一样一样的，好像可以证明。

尼姆博弈的结论是，全部异或起来为零先手输，否则先手赢。说明先手总能通过拿一定量的石头，使得剩下的异或值为零，然后零状态给后手，后手就输了，所以异或不为零，先手能赢。如果全部异或为零，由于先手必须拿至少一个，也就是说剩下的肯定比原来的小一些，那么异或起来肯定不能为零，也就是先手拿完一定会把非零的情况给后手，先手输。

现在多了一种拿法，就是拿完可以分两堆。

分类讨论，如果先手拿了非零的情况，那按照尼姆博弈的拿法，一定能变成零状态给后手，先手赢。

如果先手拿零的情况，拿完以后，剩下的如果不分，就和原来的尼姆博弈一样，一定会输，如果分两块，由于这两块之和小于原来的个数，所以他们异或一定小于原来的个数，所以一定会异或出非零的情况给后手，那么先手输了。

#include<cstdio>
int main(){
    int n,a;
    while(~scanf("%d",&n)){
        int ans=0;
        while(n--){
            scanf("%d",&a);
            ans^=a;
        }
        puts(ans?"Win":"Lose");
    }
    return 0;
}

Dice http://acm.hdu.edu.cn/showproblem.php?pid=5012

bfs 4个方向转，把转的置换写出来会比较好。用string表示状态，用map来判重，会方便很多，但是c++会ce，用g++交就ac，也是有点坑。

#include<cstdio>
#include<iostream>
#include<queue>
#include<map>
using namespace std;
string S,E;
map<string,bool> vis;
struct Q{
    int step;
    string sta;
}now,pre;
queue<Q> q;
int zhuan[4][8]={
    {2,3,1,0,4,5},
    {3,2,0,1,4,5},
    {4,5,2,3,1,0},
    {5,4,2,3,0,1},
};
int bfs(){
    vis.clear();
    vis[S]=true;
    now.sta=S;
    now.step=0;
    while(!q.empty()) q.pop();
    q.push(now);
    while(!q.empty()){
        pre=q.front();
        q.pop();
        if(pre.sta==E) return pre.step;
        for(int i=0;i<4;i++){
            for(int j=0;j<6;j++){
                now.sta[j]=pre.sta[zhuan[i][j]];
            }
            now.sta.resize(6);
            if(!vis[now.sta]){
                vis[now.sta]=true;
                now.step=pre.step+1;
                q.push(now);
            }
        }
    }
    return -1;
}
int main(){
    char op[2];
    while(~scanf("%s",op)){
        S=op[0];
        for(int i=1;i<6;i++){
            scanf("%s",op);
            S+=op[0];
        }
        E="";
        for(int i=0;i<6;i++){
            scanf("%s",op);
            E+=op[0];
        }
        printf("%d
",bfs());
    }
    return 0;
}

Number Sequence http://acm.hdu.edu.cn/showproblem.php?pid=5014

还是贪心的构造，这是参考清华大学team0790 的，每次都构造取反的数，每次都能生成全1的数。这样和最大。

#include<cstdio>
typedef __int64 LL;
const int M=100010;
LL sum;
int ans[M];
void construct(int n) {
    sum=0;
    for(int i=19; i>=0&&n>=0; i--)
        if(n&(1<<i)) {
            int s=(2<<i)-1;///s是位数和n一样的全1的数
            for(int j=s-n; j<=n; j++) {///从n按位取反到n一一赋值，每次都恰好构造出全1.
                ans[j]=s-j;
                sum+=s;
            }
            n=s-n-1;
        }
    if(!n)
        ans[0]=0;
}
int main() {
    int n,a;
    while(~scanf("%d",&n)) {
        construct(n);
        printf("%I64d
",sum);
        for(int i=0; i<=n; i++) {
            scanf("%d",&a);
            printf("%d ",ans[a]);
        }
        puts("");
    }
    return 0;
}

根据他们的算法，每个数都能匹配，并且正好能是个排列，所以就直接取反了。

#include<cstdio>
#include<algorithm>
using namespace std;
typedef __int64 LL;
const int M=100010;
int a[M],b[M],two[32];
int main(){
    int n;
    two[0]=1;
    for(int i=1;i<=20;i++){
        two[i]=two[i-1]*2;
    }
    while(~scanf("%d",&n)){
        for(int i=0;i<=n;i++){
            scanf("%d",&a[i]);
            b[i]=-1;
        }
        for(int i=n;i>=0;i--){
            if(b[i]!=-1) continue;
            int ci=upper_bound(two,two+20,i)-two;
            int fan=two[ci]-1-i;
            b[fan]=i;
            b[i]=fan;
        }
        LL ans=0;
        for(int i=0;i<=n;i++){
            ans+=i^b[i];
        }
        printf("%I64d
",ans);
        for(int i=0;i<=n;i++){
            if(i) printf(" ");
            printf("%d",b[a[i]]);
        }
        puts("");
    }
    return 0;
}

233 Matrix http://acm.hdu.edu.cn/showproblem.php?pid=5015

观察可以发现，是序列是递推的，递推10的9次方，所以矩阵快速幂了一下，关键是推出递推矩阵，每一项的都是前几项之和，第一项是233*10+3

#include<cstdio>
#include<cstring>
#define mt(a,b) memset(a,b,sizeof(a))
typedef __int64 LL;
const int mod=10000007;///%mod
class Matrix { ///矩阵 下标0开始
    typedef LL typev;///权值类型
    static const int MV=16;///矩阵长度
    static const int mod=10000007;///%mod
    friend Matrix operator *(const Matrix &a,const Matrix &b) { ///矩阵乘法，必须a的列等于b的行
        Matrix ret;
        ret.n=a.n;
        ret.m=b.m;
        ret.zero();
        if(a.m==b.n) {
            for(int k=0; k<a.m; k++) {
                for(int i=0; i<a.n; i++) {
                    if(a.val[i][k]) {
                        for(int j=0; j<b.m; j++) {
                            ret.val[i][j]+=a.val[i][k]*b.val[k][j];
                            ret.val[i][j]%=mod;///看具体需要
                        }
                    }
                }
            }
        }
        return ret;
    }
    friend Matrix operator ^ (Matrix &a,int b) {///必须是n*n方阵才能快速幂
        Matrix ret;
        ret.n=ret.m=a.n;
        ret.unit();
        for(; b; a=a*a,b>>=1) {
            if(b&1) {
                ret=ret*a;
            }
        }
        return ret;
    }
public:
    int n,m;///n行m列
    typev val[MV][MV];
    void zero() {
        mt(val,0);
    }
    void unit() {
        zero();
        for(int i=0; i<MV; i++)
            val[i][i]=1;
    }
} A;
LL a[16];
int main(){
    int n,m;
    while(~scanf("%d%d",&n,&m)){
        a[0]=3;
        a[1]=233;
        for(int i=2;i<=n+1;i++){
            scanf("%I64d",&a[i]);
        }
        A.zero();
        A.val[0][0]=1;
        A.val[1][0]=1;
        A.val[1][1]=10;
        for(int i=2;i<=n+1;i++){
            for(int j=1;j<=i;j++){
                A.val[i][j]=1;
            }
        }
        A.n=A.m=n+2;
        A=A^m;
        LL ans=0;
        for(int j=0;j<n+2;j++){
            ans+=A.val[n+1][j]*a[j];
            ans%=mod;
        }
        printf("%I64d
",ans);
    }
    return 0;
}

Ellipsoid http://acm.hdu.edu.cn/showproblem.php?pid=5017

康神写的模拟退火，我不会，待补。

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<string>
#include<queue>
#include<map>
#include<cmath>
#include<stack>
#include<algorithm>
#include<functional>
#include<stdarg.h>
using namespace std;
#ifdef __int64
typedef __int64 LL;
#else
typedef long long LL;
#endif

double esp = 10e-6;

typedef struct Point {
    double a,b,c;
    double l;
    inline double dis (const Point&p)const {
        return (p.a-a)*(p.a-a) + (p.b-b)*(p.b-b) +(p.c-c)*(p.c-c);
    }
    inline double dis()const {
        return l;
    }
    void init(double a,double b,double c) {
        this->a=a;
        this->b=b;
        this->c=c;
        l = a*a + b*b + c*c;
    }
    inline bool less(const Point&p)const {
        return l < p.l;
    }
} Point;

typedef struct {
    double a,b,c,d,e,f;
    Point ans;
    double r;
    vector<Point> testPoint;
    bool read() {
        return ~scanf("%lf%lf%lf%lf%lf%lf",&a,&b,&c,&d,&e,&f);
    }
    //随意找到一个局部最优的
    void getFirstAns() {
        r = max(a,b);
        r = max(r,c);
        ans.init(0,0,sqrt(1/r));
    }

    //得到一个范围半径
    void initRadius() {
        r = min(a,b);
        r = min(r,c);
        r = 1/r;
    }

    //模拟退火得到答案
    void solve() {

        int size;
        bool ok = false;
        while(r>esp) {
            ok = false;
            testPoint.clear();
            getTestPoint();
            size = testPoint.size();
            for(int i=0; i<size; i++) {
                if(testPoint[i].less(ans)) {
                    ans = testPoint[i];
                    ok = true;
                }
            }
            if(ok == false) {
                r = r/2;
            }

        }
    }


    void getZ(double x, double y) {
        double z;
        double a0,b0,c0;
        a0 = c;
        b0 = d*y + e*x;
        c0 = a*x*x + b*y*y + f*x*y - 1;
        double d0 = b0*b0 - 4*a0*c0;
        Point point;
        if(d0 >= 0) {
            d0 = sqrt(d0);
            z = (-b0+d0)/(2*a0);
            point.init(x,y,z);
            testPoint.push_back(point);
            z = (-b0-d0)/(2*a0);
            point.init(x,y,z);
            testPoint.push_back(point);
        }
    }
    void getY(double x,double z) {
        double y;
        double a0,b0,c0;
        a0 = b;
        b0 = d*z+f*x;
        c0 = a*x*x+c*z*z+e*x*z-1;
        double d0 = b0*b0 - 4*a0*c0;
        Point point;
        if(d0 >= 0) {
            d0 = sqrt(d0);
            y = (-b0+d0)/(2*a0);
            point.init(x,y,z);
            testPoint.push_back(point);
            y = (-b0-d0)/(2*a0);
            point.init(x,y,z);
            testPoint.push_back(point);
        }
    }
    void getX(double y,double z) {
        double x;
        double a0,b0,c0;
        a0 = a;
        b0 = e*z+f*y;
        c0 = b*y*y+c*z*z+d*y*z-1;
        double d0 = b0*b0 - 4*a0*c0;
        Point point;
        if(d0 >= 0) {
            d0 = sqrt(d0);
            x = (-b0+d0)/(2*a0);
            point.init(x,y,z);
            testPoint.push_back(point);
            x = (-b0-d0)/(2*a0);
            point.init(x,y,z);
            testPoint.push_back(point);
        }
    }

    //找目前最优解周围的若干点
    //为了简单，采用以目前最优解为中心的立方体的26*2个点作为周围点
    //任意确定两个点的坐标，可以用方程求出第三个点的坐标。
    void getTestPoint() {
        double x,y,z;
        x = ans.a;
        y = ans.b;
        z = ans.c;
        for(int i=-1; i<=1; i++) {
            for(int j=-1; j<=1; j++) {
                getZ(x+r*i,y+r*j);
                getX(y+r*i,z+r*j);
                getY(x+r*i,z+r*j);
            }

        }
    }

    double getAns() {
        return sqrt(ans.l);
    }

} Ellipsoid;

int main() {

    Ellipsoid ellipsoid;
    while(ellipsoid.read()) {
        ellipsoid.getFirstAns();
        ellipsoid.initRadius();
        ellipsoid.solve();
        printf("%.8f
",ellipsoid.getAns());
    }

    return 0;
}

end