4.4至少一题

codeforce .Accidental Victory
题目大意：给出n个数，每个数带有初始积分（不为0），随机选择两个进行比较，若初始分数相等，两个数中的一个随机胜出，若初始分数不相等，大的胜出，最后胜的数加上另一个数的分数，另一个数归0，大的数继续进行比较。问最有可能成为最后赢家的数有哪些个（从小到大输出原先的位置）。

初始思路：通过map一一对应初始的位置，而后对数值的大小进行排序，然后用前缀和，排序后每一个位子上的数和前一个数对应位置的前缀和进行比较，若前缀和大说明这个数可以成为赢家反之不行。这里考虑到两个特殊的位置，最大的数和最小的数，最大的数必然可以成为最后的赢家，最小的数不一定（只有一个最小的数的话必然不会成为赢家，若有多个则可以）
最终思路：将map数据结构换成了结构体，自定义了一种排序方式，同时发现一个特殊情况，和最大的数相邻的那个数，由特殊推出一般，一个数可以成为赢家不仅要小于前一个数对应位子上的前缀和，并且，这个数对应位置上的前缀和要小于后面一个数。否则该数不可能成为赢家（例如1 1 2 9）

放上代码：

#include<iostream>
#include<algorithm>
#include<vector>
#include<cstring>
using namespace std;
const int N=2e5+10;
typedef long long ll;
typedef struct _nnn {
    int e;
    int pri;
}mapa;
mapa a[N];
ll sum[N];
int t,n;

void sortst(mapa *a,int l,int r)
{
    if(l>=r) return ;
    int i=l-1,j=r+1,x=a[(i+j)>>1].e;
    while (i<j)
    {
        do i++;while (a[i].e<x);
        do j--;while (a[j].e>x);
        if(i<j) 
        {
            int x,y;
            x=a[i].e;
            a[i].e=a[j].e;
            a[j].e=x;
            y=a[i].pri;
            a[i].pri=a[j].pri;
            a[j].pri=y;
        }
    }
    sortst(a,l,j);
    sortst(a,j+1,r);
    
}

int main()
{
    cin>>t;
    while (t--)
    {
        memset(a,-1,sizeof(a));
        memset(sum,0,sizeof(sum));
        cin>>n;
        for (int i=1;i<=n;i++) 
        {
            int value;    
            cin>>value;
            a[i].e=value;
            a[i].pri=i;
        }
        sortst(a,1,n);
        for (int i=1;i<=n;i++) sum[i]=sum[i-1]+a[i].e;
        vector<int> sorti;
        for (int i=n;i>=1;i--)
        {
            int c=0;
            while (a[i].e==a[n].e)
            {
                sorti.push_back(a[i].pri);
                i--;
                if(i==0)
                {
                    c=1;
                    break;
                }
            }
            if(c==1)break;
            if(i!=1)
            {
                int j=i-1;
                if(sum[j]>=a[i].e)
                {
                    if(sum[i]>=a[i+1].e)
                        sorti.push_back(a[i].pri);
                    else break;
                }
                else 
                {
                    if(sum[i]>=a[i+1].e)
                        sorti.push_back(a[i].pri);
                    break;
                }
            }
            else 
            {
                if(a[i].e!=a[i+1].e) continue;
                else 
                {
                    if(sum[i]>=a[i].e) sorti.push_back(a[i].pri);
                }
            }
        }
        sort(sorti.begin(),sorti.end());
        cout<<sorti.size()<<endl;
        for (int i=0;i<sorti.size();i++)cout<<sorti[i]<<" ";
        cout<<endl;
    }
    return 0;
}

以上思路均通过代码慢慢衍生（或有不同的代码和不同的思路，不足为奇）

codeforce .D. Pythagorean Triples

不多说，完全是数学问题（写了好久优化发现是个数学问题，官方题解竟然才短短几行）

#include<iostream>
using namespace std;

int t,n;

int main()
{
    cin>>t;
    while (t--)
    {
        cin>>n;
        int ans=0;
        for (int i=3;i*i<=2*n-1;i+=2)
            ++ans;
        cout<<ans<<endl;
    }
    return 0;
}