The 2011 Nordic Collegiate Programming Contest October 01, 2011

暑期组队赛第一场，嗯，比赛的时候数据很坑爹，全部是样例，结果大家做得很开心。

然后弄到数据在自己的OJ上重开，没人欢喜都是愁啊。

Problem A Robots on a grid

一个N*N（1<=N<=1000）的棋盘，棋盘由“。”和“#”构成，点代表该格子可以走，井号代表不能走，机器人在左上角，问如果它只能向下或者向左走，有多少种方法可以走到右下角，若走不到，那如果它每次能向四周走，能不能走到。

这个题分两个阶段，第一阶段问用方法一有多少种方法，经验告诉我们这里用记忆化数组转移路径条数就可以做了。

方程为：dp[ i ] [ j ]=dp[ i-1 ] [ j ]+dp[ i ] [ j-1 ];

这里要注意的就是边界上的点只能从一个方向转换。

 第二阶段，第一想法是搜索，但是N的值太大，可能会超时，不大敢写。因为不同的路径会经过很多相同的格子，那么某一个格子【i】【j】，只要它的四周有任意一个格子能从1，1走到，那么它也能被走到，我们就可以用记忆化搜索优化一下。

//不知为何在本地会有段错误，交上去能AC

#include<iostream>
#include<stdio.h>
#include<queue>
#include<string.h>
#include<algorithm>
#define oo 2147483647
#define ll long long
using namespace std;
ll n;
char map[1010][1010];
ll dp[1010][1010],dpp[1010][1010];
ll mx[7]={0,0,1,-1};
ll my[7]={1,-1,0,0};
ll DFS(ll x,ll y){
    if (dpp[x][y]!=-1) return dpp[x][y];
    dpp[x][y]=0;
    for (ll r=0;r<4;r++){
        ll tx=x+mx[r];
        ll ty=y+my[r];
        if ( map[tx][ty]=='.'&&dpp[tx][ty]!=0&&tx>=0&&tx<n&&ty>=0&&ty<n)
            if ( DFS(tx,ty)==1)
            {
                dpp[x][y] =1;
                return 1;
            }
    }
    return 0;
}
int main()
{
    //freopen("robots.in","r",stdin);
    ll i,j,k;
    while (scanf("%lld",&n)!=EOF)
    {
        memset(dp,0,sizeof(dp));
        for (i=0;i<n;i++)
            scanf("%s",map[i]);
        for (i=0;i<n;i++)
            for (j=0;j<n;j++)
            {
                if (i==0&&j==0&&map[i][j]=='.'){dp[0][0]=1;continue;}
                if (i==0&&map[i][j]=='.'){dp[i][j]=dp[i][j-1]%oo;continue;}
                if (j==0&&map[i][j]=='.'){dp[i][j]=dp[i-1][j]%oo;continue;}
                if (map[i][j]=='.') dp[i][j]=(dp[i-1][j]+dp[i][j-1])%oo;
            }
        if (dp[n-1][n-1]) printf("%lld\n",dp[n-1][n-1]);
        else
        {
            memset(dpp,255,sizeof(dpp));
            dpp[0][0]=1;
            dpp[n-1][n-1]=DFS(n-1,n-1);
            if (dpp[n-1][n-1]==1)printf("THE GAME IS A LIE\n");
            else printf("INCONCEIVABLE\n");
        }
    }
    return 0;
}

Problem B  Mega Inversions
 题目大意：给你一串数列，对于位置 i ，找出左边位置比它大的数的个数 X 和右边位置比它小的数的个数 Y ，求出所有的X*Y的和。

这题一看就觉得是树状数组，因为只有10W的数据量。还是个模版题。建树用数列的值做下标，在插入之前计算左边有多少个值，就是左边比它小的个数，同理倒过来做一次就是右边的比它小的个数，同时用数组维护一下有多少个相等的就可以了。

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#define ll long long
using namespace std;
ll a[200010],wb[100010],b[100010],l[200010],r[200010],mx,same[100010],ss[100010];
ll cnt(ll num){
        ll sum=0;
        while (num>0){
            //cout<<sum;
              sum+=b[num];
              num-=wb[num];
              }
        return sum;
}
void ins(ll num){
     while (num<=mx){
           b[num]++;
           num+=wb[num];
           }
     return ;
}
int main(){
    //freopen("megainversions.in","r",stdin);
    int t,n,i,j,k;
    for (i=0;i<100010;i++) wb[i]=i&(-i);
    while (scanf("%d",&n)!=EOF){
          memset(b,0,sizeof(b));
          memset(l,0,sizeof(l));
          memset(r,0,sizeof(r));
          memset(same,0,sizeof(same));
          mx=0;
          for (i=0;i<n;i++)
          {
              scanf("%lld",&a[i]);
              ss[i]=same[a[i]]++;
              if (mx<a[i]) mx=a[i];
          }
          for (i=0;i<n;i++){
              l[i]=cnt(a[i]-1);
              ins(a[i]);
              }
          memset(b,0,sizeof(b));
          for (i=n-1;i>=0;i--){
              r[i]=cnt(a[i]-1);
              ins(a[i]);
              }
          ll ans=0;
          for (i=0;i<n;i++){
              ans+=(r[i]*(i-l[i]-ss[i]));
              //cout<<l[i];
          }
          printf("%lld\n",ans);
    }
    return 0;
}

Problem D  Elevator Trouble

第一眼觉得是扩展欧几里德，但是队友写的错了，于是我用模拟做的，枚举向上的次数，若超过了，看超过部分是否是向下D的倍数，第一个得到的值为最小值（这是面试位置在人位置上方的状况，分情况讨论就可以了）。

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int f,s,g,u,d,tmp;
int main()
{
    int i;
    while (scanf("%d%d%d%d%d",&f,&s,&g,&u,&d)!=EOF)
    {
        if (s==g){printf("0\n");continue;}
        if (s<g)
        {
            if (u==0||u>g-s||d>g-s) {printf("use the stairs\n");continue;}
            for (i=0;i<=1000000;i++)
            {
                tmp=s+i*u;
                if (tmp==g) {printf("%d\n",i);break;}
                if (tmp>g)
                    if ((tmp-g)%d==0)
                    {
                        printf("%d\n",i+(tmp-g)/d);
                        break;
                    }
            }
            if (i>1000000) printf("use the stairs\n");
        }
        else
        {
            if (d==0||u>g-s||d>g-s) {printf("use the stairs\n");continue;}
            for (i=0;i<=1000000;i++)
            {
                tmp=s-i*d;
                if (tmp==g) {printf("%d\n",i);break;}
                if (tmp<g)
                    if ((g-tmp)%u==0)
                    {
                        printf("%d\n",i+(g-tmp)/u);
                        break;
                    }
            }
            if (i>1000000) printf("use the stairs\n");
        }
    }
    return 0;
}

Problem E ls

模拟题，给你一个格式，其中“*”可以代表任何不包括“*”的东西，甚至为空，在给你很多字符串，输出满足格式的。

首先提取两端模式串的非“*”号字符，因为若模式串两端有非“*”字符，那么匹配串一必须有一模一样的。然后把模式串中位于两个“*”之间的字符串提取出来。匹配的时候先判断两端，在判断中间，可以一个字符一个字符的比较，因为数据只有100！

 

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<string>
#include<algorithm>
using namespace std;
int main()
{
    freopen("ls.in","r",stdin);
    freopen("my.out","w",stdout);
    char s[110],str[110],h[110],l[110],map[110][110];
    int i,j,k,lh,ll,len,n,pl,pr;
    while (scanf("%s",s)!=EOF)
    {
        ll=lh=0;
        len=strlen(s);
        if (s[0]!='*')
        {
            for (i=0;i<len;i++)
                if (s[i]!='*')
                    h[lh++]=s[i];
                else break;
        }
        if (s[len-1]!='*')
        {
            for (i=0;i<len;i++)
                if (s[len-i-1]!='*')
                    l[ll++]=s[len-i-1];
                else break;
        }
        int cnt=0,x;
        for (i=lh+1;i<len-ll;i++)
        {
            if (s[i]=='*') {cnt++,x=0;continue;}
            map[cnt][x++]=s[i];
        }
        scanf("%d",&n);
        while (n--)
        {
            scanf("%s",str);
            int ls=strlen(str);
            pl=0;pr=ls;
            if (lh!=0)
            {
                int tag=0;
                for (i=0;i<lh;i++)
                    if (str[i]!=h[i])
                    {
                        tag=1;
                        break;
                    }
                if (tag) continue;
                pl=lh;
            }
            if (ll!=0)
            {
                int tag=0;
                for (i=0;i<ll;i++)
                    if (str[ls-i-1]!=l[i])
                    {
                        tag=1;
                        break;
                    }
                if (tag) continue;
                pr=ls-ll-1;
            }
            char tmp[110];
            //cout<<pl<<pr;
            for (i=0;i<cnt;i++)
            {
                int x=0;
                for (j=pl;j<=pr;j++)
                {
                    //cout<<j<<" ";
                    for (k=0;k<strlen(map[i]);k++)
                        if (map[i][k]==str[j+k]) continue; else break;
                    //cout<<k<<" ";
                    if (k==strlen(map[i])) {x=1;break;}
                }
                pl=j;
                if (x&&i==cnt-1)
                {
                    printf("%s\n",str);
                }
                if (!x) break;
            }
        }
    }
    return 0;
}