暑假习题 2

投票游戏
信奥班的同学总是这么无聊，他们现在喜欢玩一种投票游戏。游戏规则如下，把参与游戏的同学们编号由1到N，然后他们开始投票，每个人只能投一票，只能是赞成或者反对，投票结果下来后如果赞成人数严格大于反对的人数，那么编号最小的那位同学便被踢出游戏，剩下的同学继续开始投票，直到投票僵持下来（比如剩两个人的时候一个人反对一个人赞成就会一直僵持下去），这时候游戏结束。XJ准备了一些小红花，会把他们平均分给这些剩下的同学。每个同学都想得到最多的小红花，而且不想自己被踢出。给出同学个数N，问最后剩下的同学个数，假定信奥班的同学都无比机智。
输入
一行，一个整数N
输出
一行，一个整数表示剩下的同学个数。
样例
vote.in
3
vote.out
2
数据范围
30% 1<=n<=50.
100% 1<=n<=5000.

分析：

一道很像海盗分金币的趣味题，我们采取逆推方法。
当只剩2个人时肯定僵持，所以如果有3个人，则定会淘汰一个，如果4个人，因为都不想被淘汰，1，2号肯定反对，3,4号定会赞成，则僵持，所以有5,6,7个人时定会淘汰到只剩4个人，依次类推，则如果有n个人，定会只剩2^log2(n)个人。

#include <cstdio>

using namespace std;

int n, ans;

int main() {
    freopen("vote.in", "r", stdin);
    freopen("vote.out", "w", stdout);

    scanf("%d", &n); ans = 1;
    while(ans * 2 <= n) ans *= 2;
    printf("%d\n", ans);

    return 0;
}

---

吃早饭
同学们每天早上都会晨练，但是每次运动后都会很饿，于是他们回去吃早饭，信奥班的同学们当然很有素质，他们都遵守规矩排队。每个同学都面向窗口，一共有N个同学。现在XJ想知道每个同学能够看到的前面的同学的个数和是多少。
定义一个同学能够看到的人为在他前面且身高严格低于他的人，并且他的视线会被在他前面第一个身高大于等于他的人挡住。也就是说无论如何也无法看到再前面的人了。哪怕是郭敬明。
输入
N+1行
第一行一个正整数N表示同学的个数。
以下N行分别表示从后到前（窗口）同学的身高a.
输出
一行一个整数，表示所有同学能看到的人的个数和。
样例
eat.in
6
10
3
7
4
12
2
eat.out
5
数据范围
30% 1<=N<=100,
100% 1<=N<=80000,1<=a<=1000000000.

分析：
搜索+贪心优化，sf[i]表示第i个人最远看到的那个人，从后往前搜，如果i能看到第j个人，那么一定能看到j能看到的所有人，则直接跳到j最远看到的那个人继续判断，这样将大大优化时间。

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
using namespace std;

int n;
unsigned long long h[80010],f[80010],r[80010];

int main()
{
    freopen("eat.in","r",stdin);
    freopen("eat.out","w",stdout);
    scanf("%d",&n);
    for (int i=1; i<=n; i++)
        scanf("%d",&h[i]);

    for (int i=n; i>0; i--)
    {
        int j=i+1; 
        while (j<n+1 && h[i]>h[j]) j=r[j];
        r[i]=j;
        f[i]=j-i-1;
    }

    unsigned long long ans=0;
    for (int i=1; i<=n; i++)
        ans+=f[i];
    printf("%I64u\n",ans);
return 0;
}

---

棋盘游戏
描述
现有一新型的棋盘游戏。棋盘大小为N*N，棋盘中有M个棋子，棋子每步可以往上下左右移动一步，每个棋子必须按顺序移动到一个给定的出口点，且棋子之间永远不能相邻，求移动完所有棋子的最小步数。
输入
输入数据的第一行是两个整数N，M，表示棋盘大小为N*N，和棋子个数M。
接下来有N行，每行N个数，x表示出口，o表示空地，1~M表示棋子，棋子1号棋子必须最先离开棋盘，2号其次，以此类推。
输出
输出一个数，即移动完所有棋子的最小步数，如果不能移动完则输出-1。
输入样例1
3 2
x2o
ooo
oo1
输出样例1
7
输入样例2
3 3
xo1
o2o
3oo
输出样例2
-1
数据规模
所有数据，N<=4,M<=4

分析：
典型 宽搜

#include<cstdio>
#include<queue>
using namespace std;
int dx[]={1,-1,0,0};
int dy[]={0,0,-1,1};
struct tnode
{
    int x[10],y[10];
    int step;
    int ro;
};
bool hash[7100][7100];
bool E[8][8];
queue<tnode> que;
int n,m;
bool check(tnode &node,int x)
{
    for (int i=1;i<=m;i++)
    {
        if (i==x||node.x[i]==0) continue;
        for (int j=0;j<4;j++)
        {
            if (node.x[i]+dx[j]==node.x[x] && node.y[i]+dy[j]==node.y[x]) return 0;
        }
    }
    if (E[node.x[x]][node.y[x]])
    {
        if (node.ro==x)
        {
            node.ro++;
            if (node.ro>m)
            {
                printf("%d",node.step);
                exit(0);
            }
            node.x[x]=0;
            node.y[x]=0;
        }
        else
        {
            return 0;
        }
    }
    int l=0,r=0;
    for (int i=1;i<=m;i++) l=l*10+node.x[i],r=r*10+node.y[i];
    if (hash[l][r]) return 0;
    hash[l][r]=1;
    return 1;
}

int main()
{
    memset(E,0,sizeof(E));
    memset(hash,0,sizeof(hash));
    scanf("%d%d",&n,&m);
    tnode node,newnode;
    char a;
    for (int i=1;i<=n;i++)
    {
        scanf("\n");
        for (int j=1;j<=n;j++)
        {
            scanf("%c",&a);
            if (a=='x') E[i][j]=1;
            else if (a!='o') node.x[a-'0']=i,node.y[a-'0']=j;
        }
    }
    node.step=0;
    node.ro=1;
    check(node,1);
    que.push(node);
    while (!que.empty())
    {
        node=que.front();
        que.pop();
        for (int i=1;i<=m;i++)
        {
            newnode=node;
            for (int j=0;j<4;j++)
            {
                newnode.x[i]=node.x[i]+dx[j];
                newnode.y[i]=node.y[i]+dy[j];
                if (newnode.x[i]<1||newnode.y[i]<1||newnode.x[i]>n||newnode.y[i]>n) continue;
                newnode.step=node.step+1;
                if (check(newnode,i)) que.push(newnode);
            }
        }
    }
    printf("-1");
    return 0;
}

---

敌兵布阵

题目 略

这么经典的线段树区间操作
对于更新一段区间值的操作，需要添加lazy标记来优化线段树，lazy标记是线段树的精华，必须掌握。主要思想：如果要更新的一段区间[x,y]完全包含查询到的点u的区间[l,r]，则可直接计算这段区间的sum=(r-l+1)*A，这时标记这个区间后可直接返回，因为该点子孙的相关信息我们不需要了。如果下一次要更新或查询上次标记过的点，则需要把该点的左右儿子的相关信息按照上一次的标记更新（PushDown），才不会错。

于是这里就直接代码

#include<cstdio>
#define lson l , m , rt << 1
#define rson m + 1 , r , rt << 1 | 1
#define LL long long
const int maxn = 200000 + 100;
LL sum[maxn << 2] , col[maxn << 2] ;

void pushup(int rt) {
    sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}

void pushdown(int rt,int m) {
    if(!col[rt]) return ;
    col[rt << 1] += col[rt] ;
    col[rt << 1 | 1] += col[rt];
    sum[rt << 1] += (LL)col[rt] * (m - (m >> 1));
    sum[rt << 1 | 1] += (LL)col[rt] * (m >> 1);
    col[rt] = 0 ;
}

void build(int l,int r,int rt) {
    if(l == r) {
        scanf("%d",&sum[rt]);
        return ;
    }
    int m = (l + r) >> 1 ;
    build(lson) ; build(rson) ;
    pushup(rt);
}

void update(int L,int R,int add,int l,int r,int rt) {
    if(L <= l && r <= R) {
        sum[rt] += (r - l + 1) * add ;
        col[rt] += add ;
        return ;
    }
    pushdown(rt , r - l + 1);
    int m = (l + r) >> 1 ;
    if(L <= m) update(L , R , add , lson);
    if(m < R) update(L , R , add , rson);
    pushup(rt) ;
}

LL query(int L,int R,int l,int r,int rt) {
    if(L <= l && r <= R) {
        return sum[rt];
    }
    pushdown(rt , r - l + 1) ;
    int m = (l + r) >> 1 ;
    LL res = 0 ;
    if(L <= m) res += query(L , R , lson);
    if(m < R) res += query(L , R , rson);
    return res ;
}

int main() {
    freopen("soldier.in","r",stdin);
    freopen("soldier.out","w",stdout);
    int n , m , op , a , b , x;
    scanf("%d",&n);
    build(1 , n , 1);
    scanf("%d",&m);
    while(m--) {
        scanf("%d",&op);
        if(op == 1) {
            scanf("%d%d%d",&a,&b,&x);
            update(a , b , x , 1 , n , 1);
        } else {
            scanf("%d%d",&a,&b);
            printf("%lld\n",query(a , b , 1 , n , 1));
        }
    }
    //while(1);
    return 0;
}