HDU 6205 模拟题

转载于：http://blog.csdn.net/wyxeainn/article/details/77925640

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6205

card card card

Time Limit: 8000/4000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1090    Accepted Submission(s): 482

Problem Description

As a fan of Doudizhu, WYJ likes collecting playing cards very much. 
One day, MJF takes a stack of cards and talks to him: let's play a game and if you win, you can get all these cards. MJF randomly assigns these cards into  n  heaps, arranges in a row, and sets a value on each heap, which is called "penalty value".
Before the game starts, WYJ can move the foremost heap to the end any times. 
After that, WYJ takes the heap of cards one by one, each time he needs to move all cards of the current heap to his hands and face them up, then he turns over some cards and the number of cards he turned is equal to the  penaltyvalue .
If at one moment, the number of cards he holds which are face-up is less than the  penaltyvalue , then the game ends. And WYJ can get all the cards in his hands (both face-up and face-down).
Your task is to help WYJ maximize the number of cards he can get in the end.So he needs to decide how many heaps that he should move to the end before the game starts. Can you help him find the answer?
MJF also guarantees that the sum of all "penalty value" is exactly equal to the number of all cards.

 

Input

There are about  10  test cases ending up with EOF.
For each test case:
the first line is an integer  n  ( 1≤n≤106 ), denoting  n  heaps of cards;
next line contains  n  integers, the  i th  integer  ai  ( 0≤ai≤1000 ) denoting there are  ai  cards in  i th  heap;
then the third line also contains  n  integers, the  i th  integer  bi  ( 1≤bi≤1000 ) denoting the "penalty value" of  i th  heap is  bi .

 

Output

For each test case, print only an integer, denoting the number of piles WYJ needs to move before the game starts. If there are multiple solutions, print the smallest one.

 

Sample Input

  
  

   
   5
4 6 2 8 4
1 5 7 9 2
  
  

 

Sample Output

  
  

   
   4

   
   

    
    

     
     Hint
    
    
[pre]
For the sample input:

+ If WYJ doesn't move the cards pile, when the game starts the state of cards is:
	4 6 2 8 4
	1 5 7 9 2
WYJ can take the first three piles of cards, and during the process, the number of face-up cards is 4-1+6-5+2-7. Then he can't pay the the "penalty value" of the third pile, the game ends. WYJ will get 12 cards.
+ If WYJ move the first four piles of cards to the end, when the game starts the state of cards is:
	4 4 6 2 8
	2 1 5 7 9
WYJ can take all the five piles of cards, and during the process, the number of face-up cards is 4-2+4-1+6-5+2-7+8-9. Then he takes all cards, the game ends. WYJ will get 24 cards.

It can be improved that the answer is 4.

**huge input, please use fastIO.**
[/pre]
   
   
  
  

题目意思：

给出N堆牌的数量以及该堆牌对应的权值。

WYJ可以在游戏开始前将第一堆牌放到最后的位置上，它可以执行这样的操作任意多次。

游戏开始后：WYJ按照顺序拿起每堆牌，每一次他把当前这堆牌全拿在手里然后牌面面对自己。

然后让牌面面对自己的牌翻过去和当前这堆牌对应权值相等的张数，如果某一时刻它手里的朝向

自己的牌少于当前这堆牌要求翻过去的张数，游戏就结束了，否则它就把当前这堆牌都拿走无论

这些牌是朝向自己还是背对自己。求WYJ在游戏结束时获得最多的牌数时，它在游戏开始前应该

执行多少次将第一堆牌放到最后的这个操作。

测试数据：

5

4 6 2 8 4

1 5 7 9 2

如果游戏开始前不做操作：

4-1 + 6-5 + 2-7 拿到第3堆的时候游戏结束，获得牌数4+6+2 = 12

如果游戏开始前将第一堆牌放到最后：

5

6 2 8 4 4

5 7 9 2 1

6-5 + 2-7 拿到第2堆的时候游戏结束，获得牌数：6 + 2 = 8

在上述基础上再把第一堆牌放到最后：

5

2 8 4 4 6

7 9 2 1 5

2-7 拿到第1堆的时候游戏就结束，获得排数：2

在上述基础上再把第一堆牌放到最后：

8 4 4 6 2

9 2 1 5 7

8-9 = -1 拿到第一堆牌的时候游戏结束，获得牌数： 8

在上述基础上再把第一堆牌放到最后：

4 4 6 2 8

2 1 5 7 9

4-2 + 4-1 + 6-5 + 2- 7 + 8-9 > 0.则牌全拿完了。

继续这样下去：

可以知道在游戏开始前执行四次操作。可以使游戏时获得最大牌数。

题目就是个纯模拟的过程：

AC代码：

#include <iostream>
#include <stdio.h>
#define inf 0x3f3f3f3f

using namespace std;

const int maxn = 1e6;
int num[maxn];
int value[maxn];
int a[maxn];
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        for(int i = 1; i <= n; i++)
            scanf("%d",&num[i]);
        for(int i = 1; i <= n; i++)
        {
            scanf("%d",&value[i]);
            a[i] = num[i]-value[i];
        }
        int Max = -1;   ///获得的最大卡片数
        int total_cards = 0; ///当前总卡片数
        int sum = 0;         ///求和
        int ans = 0;         ///答案
        int start = 1;       ///第几堆牌是开始
        for(int i = start; i <= n; i++)
        {
            sum += a[i];
            total_cards += num[i];
            if(sum < 0)      ///游戏结束
            {
                if(total_cards > Max)  ///更新答案
                {
                    Max = total_cards;
                    ans = start;
                }
                start = i+1;  ///下一次开始的位置是i+1,这个很容易明白的
                sum = 0;
                total_cards = 0;
            }
        }
        ///从start ~ n 还要再加上从1~start，因为他们开始前被挪到了后边
        for(int i = 1; i < start; i++)
        {
            sum += a[i];
            total_cards += num[i];
            if(sum < 0)
            {
                if(total_cards > Max)
                {
                    Max = total_cards;
                    ans = start;
                }
                break;
            }
        }
        if(total_cards > Max)
        {
            Max = total_cards;
            ans = start;
        }
        printf("%d\n",ans-1);  ///从第ans开始，执行操作ans-1次
    }
    return 0;
}