数据范围很小，四层循环暴力也能过，枚举操作次数，左边取的个数和右边取的个数，剩下的次数可以用来丢掉负数

csdn推荐

A.Hcode OnlineJudge

给出一个N面骰子和整数K，掷出1-N之间的每个数的概率相同，每次掷出一次，记为成绩，若成绩小于K，则开始抛硬币，硬币朝上则数翻倍，反之则为0，概率都为0.5。当数大于等于K或等于0时结束。求成绩大于等于K的概率。

英文题目读假了，写不出来。其实只需要把每个数的概率分别求出来再求和就行了，注意乘上掷出该数的概率

#include
#define endl 'n'
#define mk make_pair
#define int long long
using namespace std;
typedef long long ll;
typedef pair PII;
const int N = 1e5+10;
const int mod = 998244353;
int n,m,k;
void sovle(){
    cin>>n>>m;
    double a,b=0.000000000;
    a=n*1.000000000;
    a=1/a;
    for(int i=1;i<=n;i++){
        int u=i;
        double c=1.000000000;
        while(u>t;
    while (t--){
        sovle();
    }
    return 0;
}

B.Hcode OnlineJudge

给出ABCD四个操作和一个双端队列，要求你通过不超过K次的操作，使得所得整数之和最大

正解应该是队列，我用数组也过了。

数据范围很小，四层循环暴力也能过，枚举操作次数，左边取的个数和右边取的个数，剩下的次数可以用来丢掉负数

#include
#define endl 'n'
#define mk make_pair
#define int long long
using namespace std;
typedef long long ll;
typedef pair PII;
const int N = 1e5+10;
const int mod = 998244353;
int n,m,k;
void sovle(){
    cin>>n>>m;
    vectora(n);
    for(int i=0;i>a[i];
    }
    int max1=0;
    for(int i=0;i<=m;i++){
        for(int j=0;j<=i;j++){
            vectorb,c;
            for(int w=0;w<j;w++){
                b.push_back(a[w]);
            }
            for(int u=0;u<=i&&u+j<=i&&u+j=n-u&&e>=j;e--){
                    b.push_back(a[e]);
                }
                if(!(u+j)) continue;
                c=b;
                sort(c.begin(),c.end());
                int x;
               	x=i-j-u;
                int y=0;
                while(x>0){
                    x--;
                    if(c[y]<0&&y<c.size()){
                        y++;
                    }
                }
                int sum=0;
                for(;y=n-u&&e>=j;e--){
                    b.pop_back();
                }
            }
        }
    }
    cout<<max1<>t;
    while (t--){
        sovle();
    }
    return 0;
}

C.Hcode OnlineJudge

实际上就是求组成最少几个的递增序列。

有点像窗口排队问题，用一个数组维护队尾就好了，每次二分查询现有的队伍中小于该数的最大队尾，并将队尾修改成该数，如果没有则新开一队，也就是往后插入这个数。显然，这个数组总是满足非递减的单调性，具有二分性。

#include
#define endl 'n'
#define mk make_pair
#define int long long
using namespace std;
typedef long long ll;
typedef pair PII;
const int N = 1e9+10;
const int mod = 998244353;
int n,m,k;
int cmp(PII a,PII b){
    return a.first>n;
    vectora(n);
    vectorb;
    for(int i=0;i>a[i];
    }
    int sum=1;
    b.push_back(a[0]);
    for(int i=1;i<n;i++){
        int l=0,r=b.size(),ans=-1;
        while(l<=r&&(l+r)/2>1;
            if(b[mid]<a[i]){
                r=mid-1;
                ans=mid;
            }else{
                l=mid+1;
            }
        }
        if(ans!=-1){
            b[ans]=a[i];
        }else{
            b.push_back(a[i]);
            sum++;
        }
    }
    cout<<sum<>t;
    while (t--){
        sovle();
    }
    return 0;
}

#include
#define endl 'n'
#define mk make_pair
#define int long long
using namespace std;
typedef long long ll;
typedef pair PII;
const int N = 1e5+10;
const int mod = 998244353;
int n,m,k;
void sovle(){
    cin>>n>>m;
    mapa;
    for(int i=0;i>k;
        a[-k]++;
    }
    for(int i=0;i>x>>y;
        a[-y]+=x;
    }
    int sum=0;
    for(auto ed:a){
        if(ed.second<=n){
            sum+=-ed.first*ed.second;
            n-=ed.second;
        }else{
            sum+=-ed.first*n;
            break;
        }
    }
    cout<<sum<>t;
    while (t--){
        sovle();
    }
    return 0;
}