Codeforces#378 div.2 C. Epidemic in Monstropolis

题意：给定n个数，代表n个怪物的质量，当一个怪物严格大于两边怪物质量时，可以吃掉来增加自己的质量，一个怪物同一时间只会被吃一次。问能否出现这样一种情况：给定k个数，代表剩下怪物的质量。

显然需要分组，不管怎么吃，每一组的质量和都对应一个ki。
思路：对每个数组，每次选取当前的最大值（注意最大值连续的情况），吃掉左或右的怪物，移动数组元素代表的值。

注意点：
一开始考虑数组还是链表，链表可以直接找到左右两边的值，不需要像数组一样判断。但是链表判断结束会有点困难，大概是可以的吧。

代码我写了很久，调试了更久。写得久的原因是思路不清晰，输出的位置不一定就是实际位置，
在数组中的位置如果是i，那么实际输出的位置就是pn[i].first，代表的值是pn[i].second。一开始总想着把i和pn[i].first作为一个处理，但是那样数组的元素不好定位，数组的个数也要不断减少。

如果吃掉了左边，自己和自己右边的输出位置全部都要-1。如果吃掉了右边，自己的输出位置则是不变的。

判断结束有很多个点。
1.首先n数列所有的值的和肯定等于k数列的和；
2.如果累加的和直接大于k[i]，那么直接判NO；
3.查找最大元素的时候，注意最大元素连续时，如果不停地选取其中一个，可能会陷入死循环。
设定每次吃掉一个怪物，num-1，直到整个组只有一个元素。
所以如果最大值连续，每次都吃不到怪物，那么会进行下一次最大值筛选，然而筛选的还是这个值。
所以我筛选时最大值左右两边肯定存在一个不相等的数。
然后找到后由于左右两边肯定有不同的数，
所以操作肯定可以进行。
筛选最大值时，如果整个组都是一样的，注意要判NO，这里还有一个情况，就是一组只有1个元素，然后算一样的，判NO。可答案应该是YES。

之所以选择最大值而不能直接顺序遍历，是因为可能会有这组
样例：
3
3 2 5
1
10
如果顺序的话，3先吃掉2，然后和5互相吃不了，判NO。
实际上应该先让5吃2，再吃3。

答案最后输出，所以用队列存。

大概也就这么多了。能做出来多亏了事后的样例。
那么多数据大概都是HACK的人写的。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 100000000+5;
int n,k,sum=0,last;
typedef pair<int,int> pp;
typedef pair<int,char> pc;
queue<pair<int,char> > que;
int sear(int ks,int kn,pp *pn,int ki)
{
    int min_n=MAXN,max_n=-1,k,p;
    if(ks!=kn)
    for(int i=ks;i<=kn;i++){
        if(pn[i].first){
            if(pn[i].second<min_n) min_n=pn[i].second;
            if(pn[i].second>max_n) max_n=pn[i].second;
        }
    }
    if(min_n==max_n) return false;
    int ans=0,maxn=-1;
    for(int i=ks;i<=kn;i++){
        if(pn[i].second>maxn) {
            ans=i;
            maxn=pn[i].second;
        }
    }
    for(int i=ks;i<=kn;i++){
        if(pn[i].first!=0&&pn[i].second==maxn){
            for(k=1;i+k<=kn;k++){
                if(pn[i+k].first) break;
            }
            for(p=1;i-p>=ks;p++){
                if(pn[i-p].first) break;
            }
            if(i+k<=kn&&pn[i].second!=pn[i+k].second){
                ans=i;
                break;
            }
            else if(i-p>=ks&&pn[i].second!=pn[i-p].second){
                ans=i;
                break;
            }
        }
    }
    return ans;
}
bool solve(int ks,int kn,pp* pn,int ki)
{
    int k,num=kn-ks+1,i,p;
    //cout<<ks<<kn<<endl;
    while(num){
        if(!(i=sear(ks,kn,pn,ki))) return false;
        num--;
        for(k=1;i+k<=kn;k++){
            if(pn[i+k].first) break;
        }
        //cout<<pn[i].second<<ends<<pn[i+k].second<<endl;
        if(i+k<=kn&&pn[i].second>pn[i+k].second){
            que.push(pc(pn[i].first,'R'));
            pn[i+k].first=0;
            pn[i].second+=pn[i+k].second;
            //cout<<1<<endl;
            for(int j=i+k+1;j<=kn;j++){
                if(pn[j].first) pn[j].first--;
            }
        }
        for(p=1;i-p>=ks;p++){
            if(pn[i-p].first) break;
        }
        if(i>=p+ks&&pn[i].second>pn[i-p].second){
            que.push(pc(pn[i].first,'L'));
            pn[i-p].first=0;
            pn[i].second+=pn[i-p].second;
            for(int j=i;j<=kn;j++){
                if(pn[j].first) pn[j].first--;
            }
        }
        if(pn[i].second==ki) return true;
    }
    return true;
}

int main()
{
    cin>>n;
    pp *pn=new pp[n+1];
    for(int i=1;i<=n;i++){
        cin>>pn[i].second;
        sum+=pn[i].second;
    }

    cin>>k;
    int *ink=new int[k+1];

    for(int i=1;i<=k;i++){
        cin>>ink[i];
        sum-=ink[i];
    }

    if(sum) {
        cout<<"NO"<<endl;
        return 0;
    }
    sum=0;
    for(int i=1,last=1;i<=k;i++){
        for(int j=last,ki=1;j<=n;ki++,j++){
            sum+=pn[j].second;
            pn[j].first=ki+i-1;
            if(sum==ink[i]){
                sum=0;
                if(!solve(last,j,pn,ink[i])){
                    cout<<"NO"<<endl;
                    return 0;
                }
                last=j+1;
                break;
            }
            else if(sum>ink[i]) {
                cout<<"NO"<<endl;
                return 0;
            }
        }
    }
    cout<<"YES"<<endl;
    while(!que.empty()){
        cout<<que.front().first<<' '<<que.front().second<<endl;
        que.pop();
    }
    return 0;
}