C

//简单的发现k=0，k=1，k=2，k》=3是三种情况
//0，找数组最小值
//1，加个排序后相邻差的最小值
//2，找出第一次差的所有可能值给原数组二分找左右值各自做差后的绝对值
//3，等于0
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
void solve(){
    int n,k;
    cin>>n>>k;
    vector<ll> vc(n);
    ll mmin=1e18;
    for(int i=0;i<n;i++){
        cin>>vc[i];
        mmin=min(vc[i],mmin);
    }
    if(k>=3) {cout<<0<<"\n";return ;}

    sort(vc.begin(),vc.end());
    if(k>=1)for(int i=n-1;i>=1;i--){
        mmin=min(mmin,vc[i]-vc[i-1]);
        if(!mmin){cout<<0<<"\n";return ;

        }
    }
    if(k==2){
    vector<ll> temp;
    for(int i=0;i<n;i++){
        for(int j=0;j<i;j++){
            temp.emplace_back(vc[i]-vc[j]);
        }
    }   
    sort(temp.begin(),temp.end());
    temp.erase(unique(temp.begin(),temp.end()),temp.end());
    for(int i=0;i<n;i++){
        int index=lower_bound(temp.begin(),temp.end(),vc[i])-temp.begin();
        if(index!=(int)temp.size()) mmin=min(temp[index]-vc[i],mmin);
        if(index>0)  mmin=min(abs(temp[index-1]-vc[i]),mmin);
    }

    }
    cout<<mmin<<"\n";
}
//4195877197095204
//899214809992477
int main(){
    int t;
    cin>>t;
    while(t--){
        solve();
    }
}

B

//这道题有动态规划的思想无后效性，依赖关系，最大值的覆盖个数是n-1，次最大值的“前缀///和”（定义小于它的所有数字和）如果大于最大值，那么它的覆盖个数=最大值，否则，等于
//index-1；利用依赖关系推广就可以
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define x first
#define y second
typedef pair<ll,ll> pii;
void solve(){
    ll n;
    cin>>n;
    vector<pii> vc(n);
    vector<pii> edge(n);
    for(ll i=0;i<n;i++){
        cin>>vc[i].x;
        edge[i].x=vc[i].x;
        edge[i].y=i;
    }
    sort(edge.begin(),edge.end());

    //cout<<"\n";
    for(ll i=1;i<n;i++){
        edge[i].x+=edge[i-1].x;
    }
    vc[edge[n-1].y].y=n-1;
    for(ll i=n-2;i>=0;i--){
        if(edge[i].x >= vc[edge[i+1].y].x) vc[edge[i].y].y=vc[edge[i+1].y].y;
        else vc[edge[i].y].y=i;
    }
    for(auto [i,j]:vc){
        cout<<j<<" ";
    }
    cout<<"\n";
}
int main(){
    int t;
    cin>>t;
    while(t--){
        solve();
    }


}

D1

//这道题是简单版本，莫名就搞出来了
//看题解前我无法证明，就是猜，猜的思路是：
//还是利用动态规划的无后效性思想，如果随便去更新a数组的值去对应模板数组b
//那么会造成重复更新，导致不优解（错解），先更新a大元素的对途经过a中小元素的影响是///不可逆的，小元素更新对此没有影响，那么我们优先去从小到大的更新，但是此时问题又来///了，左右都有值的时候我要选谁比较好呢，我直接猜两个都要，但是现在想想，由于
//无后效性，和我的代码更新方式，使得两个都更新对答案没影响（为什么写着写着我就
//极其不严谨的逻辑自洽，hh）
//来看看标准答案的解答：自己看去，异曲同工
#include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
typedef pair<int,int> pii;
void solve(){
    int n;
    cin>>n;
    vector<int> vc(n),cop(n);
    vector<pii> edge(n);
    for(int i=0;i<n;i++){
        cin>>vc[i];
    }
    for(int i=0;i<n;i++) {cin>>cop[i];
    edge[i].x=cop[i];
    edge[i].y=i;
    }
    bool falg=true;
    sort(edge.begin(),edge.end());

    for(int i=0;i<n;i++) {
        //cout<<"pp";
        //cout<<edge[i].y<<" ";
        if(edge[i].x==vc[edge[i].y]) continue;
        else if(edge[i].x<vc[edge[i].y]){
            falg=false;
            break;
        }
        int r=edge[i].y+1;
        int l=edge[i].y-1;
        int mu=edge[i].x;
        while(l>=0&&vc[l]<mu&&cop[edge[i].y]<=cop[l]){
            vc[l]=mu;
            l--;
        }
        while(r<n&&vc[r]<mu&&cop[edge[i].y]<=cop[r]){
            vc[r]=mu;
            r++;
        }
        if(l<0&&vc[r]!=mu||r>=n&&vc[l]!=mu||r>=n&&l<0||r<n&&l>=0&&vc[r]!=mu&&vc[l]!=mu){
            falg=false;
            break;
        }

    }
    if(falg) cout<<"YES\n";
    else cout<<"NO\n";

}
int main(){
    int n;
    cin>>n;
    while(n--){
        solve();
    }

}

B

//抓住gij=ai|aj。由于|是和的性质，所有所有的gxi都会含有ai的所有位置，所以对
//所有的gxi进行&就可以，记得回头检验是不是相同排除等于0的时候的特殊情况
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
void solve(){
    int n;
    cin>>n;
    ll g[n][n];
    ll ans[n];

    for(int i=0;i<n;i++){
        ans[i]=(1<<30)-1;
        for(int j=0;j<n;j++){
            cin>>g[i][j];
        }
    }
    if(n==1){
        cout<<"YES\n1\n";
        return ;
    }
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            if(i==j) continue;
            ans[i]&=g[j][i];
        }
    }
    bool falg=true;
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            if(i==j)continue;
            if((ans[i]|ans[j])!=g[i][j]) {falg=false;break;}
        }
    }
    if(falg){
        cout<<"YES\n";
        for(int i=0;i<n;i++){
            cout<<ans[i]<<" ";
        }
        cout<<"\n";
    }else{
        cout<<"NO\n";
    }
}
int main(){
    int t;
    cin>>t;
    while(t--){
        solve();
    }
}

C
钓鱼题所在记录（第一道就是）

//“二”刷来了
//依稀记得某场dvi2的c题被此折磨，后面一直不理解，那道钓鱼题...
//不妨从记录后缀和，然后每一段都拆开，那激素1*（s1-s2）+2*（s3-s2）+3*（s4-s3）
//+4*（s5-s4）；化简后就是s1+s2+s3，也就是后缀一旦大于0就分组

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
void solve(){
    ll n;
    cin>>n;
    vector<ll> vc(n);
    for(int i=0;i<n;i++){
        cin>>vc[i];
    }
    ll k=0;
    ll temp=0;
    for(ll i=n-1;i>=0;i--){
        temp+=vc[i];
        if(temp>=0){
            k++;
        }
    }
    if(temp<0){
        k++;
    }
    ll tmp=0;
    temp=0;
    ll cnt=0;
    for(ll i=n-1;i>=0;i--){
        temp+=vc[i];
        tmp+=vc[i];
        if(temp>=0){
            cnt+=k*tmp;
            tmp=0;
            k--;
        }

    }
    cnt+=tmp;
    cout<<cnt<<"\n";
}
int main(){
    int t;
    cin>>t;
    while(t--){
        solve();
    }
}

//待补
1，D2 （不是好高骛远，是因为我看到题解里面说可以用单调栈优化）
2，高跟鞋题
3，D1
(不是好高骛远，而是因为是1600而且我想到了拆位和贪心的方法，就差调参数了)