【2017沈阳网络赛】1012 hdu6205 card card card 贪心

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 ith integer ai (0≤ai≤1000)
denoting there are ai cards
in ith heap;

then the third line also contains n integers,
the ith integer bi (1≤bi≤1000)
denoting the "penalty value" of ith 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堆牌，原本每一堆的所有牌（a[i]张）默认向下，每次从第一堆开始，将固定个数的牌（b[i]张）翻上，然后下一堆继续，直到没有足够的牌翻上，然后你可以获得当前已经操作过的堆的所有牌。最初你可以调整堆的顺序，把第一堆放到最后一堆（逆时针旋转），你可以重复这个操作，问你要重复多少次这个操作，才能获得最多的牌。

思路：

先得到一个前提，由一定能获得所有的牌。

然后就用贪心的思想，从头开始取，如果和小于0，之前所有的牌就都必须移动。然后从下一个值开始取。

#include <iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#define ll long long
using namespace std;
const int N=1100000;
int n,a
,b
,c
;

template <class T>
bool read(T &ret)
{
char c;
int sgn;
T bit = 0.1;
if (c=getchar(), c==EOF)
{
return 0;
}
while (c != '-' && c != '.' && (c < '0' || c > '9'))
{
c = getchar();
}
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9')
{
ret = ret * 10 + (c - '0');
}
if (c == ' ' || c == '\n')
{
ret *= sgn;
return 1;
}
while (c = getchar(), c >= '0' && c <= '9')
{
ret += (c - '0') * bit, bit /= 10;
}
ret *= sgn;
return 1;
}

int main(int argc, const char * argv[]) {
while(read(n))
{
for(int i=0;i<n;i++)    read(a[i]);
for(int i=0;i<n;i++)    read(b[i]);
for(int i=0;i<n;i++)    c[i]=a[i]-b[i];
ll sum=0;
int ans=0;
for(int i=0;i<n;i++)
{
sum+=(ll)c[i];
if(sum<0)
{
ans=i+1;
sum=0;
}
}
printf("%d\n",ans);
}
}