2017 ACM/ICPC Asia Regional Shenyang Online - card card card

HDU - 6205：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): 26    Accepted Submission(s): 10

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]

   
   
   
    
  
  

 

Source

2017 ACM/ICPC Asia Regional Shenyang Online 

 

题意：

有n堆扑克牌第i对有ai张，拿走第i堆之后要给出bi张扑克，若给不出，不能再拿下一堆（按从左到右的顺序拿）。

在还没开始拿的时候可以执行把最左边的一堆放到最后的操作，然后再开始拿。

求拿过（包括给出去的）最多的时候操作了几次，当相同时就取操作少的。

思路：

从第一个推到最后一个，先求出不操作时最远可以拿到的位置，记录当时拿过的扑克数以及剩余的扑克数。

然后就按顺序推下去，并更新数据得到答案。

比赛的时候两个地方没考虑到，就是不操作时和操作之后可以拿到所有且剩余的扑克≥0的时候pos没有记录。

#include<iostream>
#include<stdio.h>
#include<string.h>
#define LL long long
using namespace std;
const LL maxn = 1e6;
int n,a[maxn*2+10],b[maxn*2+10];
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++) scanf("%d",&a[i]),a[i+n]=a[i];
        for(int i=1;i<=n;i++) scanf("%d",&b[i]),b[i+n]=b[i];
        LL get = 0,have = 0,pos = 0,mx = 0,k = 0,flag = 0;//flag=1时说明可以全收了就不用再移了
	//拿过的  剩余的   当前位置  最多拿过的 移动次数   
        for(int i=1;i<=n;i++)
        {
            get += a[i];
            have += a[i]-b[i];
            if(i==n) flag = 1;
            if(have<0){pos = i;break;}
        }
        mx = get;
        for(int i=1;i<n&&!flag;i++)
        {
            get -= a[i];
            have -= a[i]-b[i];
            if(have<0) continue;
            for(int j=max((int)pos,i)+1;j<=n+i;j++)
            {
                get += a[j];
                have += a[j] - b[j];
                if(have<0){pos = j;break;}
            }
            if(get>mx) mx = get,k = i;
            if(pos==n+i) flag = 1;
        }
        printf("%lld\n",k);
    }
    return 0;
}