NOIP2014-9-6模拟赛

1. 工资

(money/money.in/money.out)

时限1000ms 内存256MB

聪哥在暑假参加了打零工的活动，这个活动分为n个工作日，每个工作日的工资为Vi。有m个结算工钱的时间,聪哥可以自由安排这些时间，也就是说什么时候拿钱，老板说的不算，聪哥才有发言权！（因为聪哥是土豪，他是老板的老板）

聪哥不喜欢身上一次性有太多的钱，于是他想安排一下拿钱的时间，使他一次性拿的钱中最大的最小。（最后一天一定要领钱）

输入

第一行 2个数 n,m

接下来n行，每行一个数，代表Vi.

输出

最小的最大钱数。

样例输入

7 5

100

400

300

100

500

101

400

样例输出

500

 

样例说明

100 400//300 100//500//101//400//

“//”表示老大要去拿钱。

 

数据范围

20%   1<=n<=20

另 20%  1<=n<=50,Vi的和不超过1000

100%  1<=n<=100,000,m<=n,Vi<=10,000

第二题  藏妹子之处（excel）

问题描述：

今天CZY又找到了三个妹子，有着收藏爱好的他想要找三个地方将妹子们藏起来，将一片空地抽象成一个R行C列的表格，CZY要选出3个单元格。但要满足如下的两个条件：

（1）任意两个单元格都不在同一行。

（2）任意两个单元格都不在同一列。

选取格子存在一个花费，而这个花费是三个格子两两之间曼哈顿距离的和（如(x1,y1)和(x,y2)的曼哈顿距离为|x1-x2|+|y1-y2|）。狗狗想知道的是，花费在minT到maxT之间的方案数有多少。

答案模1000000007。所谓的两种不同方案是指：只要它选中的单元格有一个不同，就认为是不同的方案。

输入格式：

 一行，4个整数，R、C、minT、maxT。3≤R,C≤4000, 1≤minT≤maxT≤20000。

对于30%的数据,  3 ≤ R, C ≤ 70。 

输出格式:

 一个整数，表示不同的选择方案数量模1000000007后的结果。

输入输出样例：

输入样例	3 3 1 20000	3 3 4 7	4 6 9 12	7 5 13  18	4000 4000  4000  14000
输出样例	6	0	264	1212	859690013

Problem 3 银河之星(galaxy.cpp/c/pas)

---

T1:

二分贪心

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#define MAXN 100005
#define ll long long
using namespace std;
int a[MAXN];
int n,m;
int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if('-'==ch)f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int check(int w){
    int cnt=1,s=0;
    for(int i=1;i<=n;i++){
        if(s+a[i]>w){
            cnt++;
            if(cnt>m){
                return 0;
            }
            s=a[i];
        }
        else{
            s+=a[i];
        }
    }
    return 1;
}
int main()
{
    int L=0,R=0;
    n=read();m=read();
    for(int i=1;i<=n;i++){
        a[i]=read();
        R+=a[i];
        L=max(L,a[i]);
    }
    while(R-L>1){
        int mid=((ll)R+(ll)L)/2;
        if(check(mid)){
            R=mid;
        }
        else{
            L=mid+1;
        }
    }
    if(check(L)){
        printf("%d
",L);
    }
    else{
        printf("%d
",R);
    }
    return 0;
}

---

T2:

数学分析,发现代价就是三个点组成的矩形的边长，枚举之后分两种情况：

1，两个点在矩形的对角线顶点，第三点到处逛~
左上-右下对角线 (x-1)*(y-1)
左下-右上对角线 (x-1)*(y-1)
2，一个点在矩形的一个顶点，其余两个点分别在其余的两条边
(x-1)(y-1)
然后矩形有4个顶点，所以是4*(x-1)(y-1)
可以证明，至少有一个点在矩形的顶点处
所以根据加法原理，有6*(x-1)(y-1)种情况，
然后矩形可以在局域里面到处跑，总共可以跑(n-x+1)*(m-y+1)处
乘起来即可

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#define MOD 1000000007
#define ll long long
using namespace std;
ll n,m,s,t;
ll ans;
int main()
{
//    freopen("data.in","r",stdin);
    scanf("%lld%lld%lld%lld",&n,&m,&s,&t);
    n--;m--;
    if(s%2==1) s++;
    if(t%2==1) t--;
    if(t>(n+m)*2){
        t=(n+m)*2;
    }
    for(ll i=s;i<=t;i+=2){
        ll d=i/2;
        for(ll j=max(1LL,d-m);j<=min(n,d-1);j++){
            ans=(ans+(6*(j-1)*(d-j-1))%MOD*(n-j+1)%MOD*(m-(d-j)+1)%MOD)%MOD;
        }
    }
    printf("%lld
",ans);
    return 0;
}

---

T3:

一开始以点的位置为状态，用hash加搜索，结果好慢好慢啊，T了8个点

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include<queue>
#define MAXN 105
#define MOD 1000003
#define P 17
#define pii pair<int,int>
using namespace std;
int gx[8]={0,0,1,1,1,-1,-1,-1};
int gy[8]={1,-1,1,0,-1,1,0,-1};
int k,n,m,x0,y0;
bool b[MOD];
struct Node{
    int s;
    pii p[11];
};
queue<Node> q;
int hash(Node t){
    int ret=0;
    for(int i=0;i<k;i++){
        if(t.s&(1<<i)){
            ret=(ret+t.p[i].first*MAXN+t.p[i].second)%MOD;
        }
        ret=ret*P%MOD;
    }
    return ret;
}
int Abs(int x){
    return (x>0)?x:-x;
}
int bfs(){
    while(!q.empty()){
        int s=q.front().s;
        pii p[11];
        memcpy(p,q.front().p,sizeof(p));
        q.pop();
        int L=0,cnt;
        for(int i=0;i<k;i++){
            if(s&(1<<i)){
                L++;
                cnt=i;
            }
        }
        if(1==L){
            if(Abs(p[cnt].first-x0)%3==0&&Abs(p[cnt].second-y0)%3==0){
                return 1;
            }
            continue;
        }
        int a[MAXN][MAXN]={0};
        for(int i=0;i<k;i++){
            if(s&(1<<i)){
                a[p[i].first][p[i].second]=i+1;
            }
        }
        for(int i=0;i<k;i++){
            if(s&(1<<i)){
                for(int d=0;d<8;d++){
                    int dx=p[i].first,dy=p[i].second;
                    for(int j=1;j<=3;j++){
                        dx+=gx[d];
                        dy+=gy[d];
                    }
                    if(1<=dx&&dx<=n&&1<=dy&&dy<=m&&!a[dx][dy]){
                        Node t;
                        t.s=s;
                        memcpy(t.p,p,sizeof(t.p));
                        t.p[i]=make_pair(dx,dy);
                        int h=hash(t);
                        if(!b[h]){
                            b[h]=1;
                            q.push(t);
                        }
                    }
                }
            }
        }
        for(int i=0;i<k;i++){
            if(s&(1<<i)){
                for(int d=0;d<8;d++){
                    int dx=p[i].first,dy=p[i].second;
                    dx+=gx[d];
                    dy+=gy[d];
                    if(a[dx][dy]){
                        int v=a[dx][dy]-1;
                        dx+=gx[d];
                        dy+=gy[d];
                        if(1<=dx&&dx<=n&&1<=dy&&dy<=m&&!a[dx][dy]){
                            Node t;
                            t.s=s^(1<<v);
                            memcpy(t.p,p,sizeof(t.p));
                            t.p[i]=make_pair(dx,dy);
                            int h=hash(t);
                            if(!b[h]){
                                b[h]=1;
                                q.push(t);
                            }
                        }
                    }
                }
            }
        }
    }
    return 0;
}
void solve(){
    memset(b,0,sizeof(b));
    while(!q.empty()) q.pop();
    Node t;
    t.s=(1<<k)-1;
    for(int i=0;i<k;i++){
        scanf("%d%d",&t.p[i].first,&t.p[i].second);
    }
    b[hash(t)]=1;
    q.push(t);
    if(bfs()){
        printf("Yes
");
    }
    else{
        printf("No
");
    }
}
int main()
{
//    freopen("data.in","r",stdin);
    while(~scanf("%d%d%d%d%d",&k,&n,&m,&x0,&y0)){
        solve();
    }
    return 0;
}

后来发现，应当抓住问题的性质，即能否到达，而不是最短距离之类
由于坐标相差3的倍数的点可以互相移动到达，不妨认为就是一个点了，然后只会存在9种点
0 1 2 0 1 2
3 4 5 3 4 5
6 7 8 6 7 8
0 1 2 0 1 2
3 4 5 3 4 5
6 7 8 6 7 8
这样移动三步的情况就解决了
然后移动两步比如0+4=8 3+4=5
注意需要考虑这种情况
1 X X
X X X
X X 1
一般来说0+8=4
但是这种情况下地图只有这么小，你的0跑到8底下就超出范围了
所以不能直接计算，需要枚举处理合法的情况
然后问题迎刃而解了

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include<map>
#define MAXN 102
#define P 11
#define ll long long
using namespace std;
map<ll,bool> mp;
int gx[]={0,0,-1,-1,-1,1,1,1};
int gy[]={-1,1,-1,0,1,-1,0,1};
int K,n,m,ed;
int G[10][10];
ll hash(int a[9]){
    ll ret=0;
    for(int i=0;i<9;i++){
        ret=ret*P+a[i];
    }
    return ret;
}
int place(int x,int y){
    return ((x-1)%3)*3+(y-1)%3;
}
void init(){
    memset(G,-1,sizeof(G));
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            for(int k=0;k<8;k++){
                int x1=i+gx[k],y1=j+gy[k];
                int x2=x1+gx[k],y2=y1+gy[k];
                if(1<=x2&&x2<=n&&1<=y2&&y2<=m){
                    int t1=place(i,j);
                    int t2=place(x1,y1);
                    int t3=place(x2,y2);
                    G[place(i,j)][place(x1,y1)]=place(x2,y2);
                }
            }            
        }
    }
}
int dfs(ll x){
    if(x==ed){
        return 1;
    }
    int b[9]={0};
    for(int i=8;i>=0;i--){
        b[i]=x%11;
        x/=11;
    }
    for(int i=0;i<9;i++){
        for(int j=0;j<9;j++){
            if(b[i]&&b[j]&&G[i][j]!=-1){
                int d[9]={0};
                memcpy(d,b,sizeof(d));
                d[i]--;
                d[j]--;
                d[G[i][j]]++;
                ll h=hash(d);
                if(!mp[h]){
                    mp[h]=1;
                    if(dfs(h))
                        return 1;
                }
            }
        }
    }
    return 0;
}
int main()
{
//    freopen("data.in","r",stdin);
    int x,y;
    while(~scanf("%d%d%d%d%d",&K,&n,&m,&x,&y)){
        mp.clear();
        init();
        int b[9]={0};
        b[place(x,y)]++;
        ed=hash(b);
        b[place(x,y)]--;
        for(int i=1;i<=K;i++){
            scanf("%d%d",&x,&y);
            b[place(x,y)]++;
        }
        ll h=hash(b);
        mp[h]=1;
        if(dfs(h)){
            printf("Yes
");
        }
        else{
            printf("No
");
        }
    }
    return 0;
}

这是一道搜索的好题，提醒我们铭记问题的性质决定求解的方法