Codeforces Round #746 (Div. 2)

#include 
#define yes puts("yes");
#define inf 0x3f3f3f3f
#define ll long long
#define linf 0x3f3f3f3f3f3f3f3f
#define debug(x) cout<<"> "<< x< PII;
const int N =10 + 1e5 ,mod=1e9 + 7;
int n;
int a[N];
void solve()
{    
    int H;
    cin>>n>>H;
    for(int i=0;i>a[i];
    sort(a,a+n,greater());
    int x = a[1],y = a[0];
    int tot = H/(x+y) * 2; 
    H%=(x+y);
    int i=0;
    while(H>0){
        tot++;
        if(i&1) H -= x;
        else H -= y;
        i++;
    }
    cout<>T;
    while(T--)
        solve();

    return 0;
}

对一个序列进行排序，用以下操作，问最后能不能排好。
如果两个元素 a i a_i ai​, a j a_j aj​,满足 ∣ i − j ∣ > = x |i-j|>=x ∣i−j∣>=x，则可以进行交换，反之不行

key point：对d进行分类讨论
-如果d非常大，无法排序是显然的

• 如果d = 1 ，一定可以进行排序
• 对首尾元素的交换范围进行分析可以发现，如果d比较小，任意位置的元素可以交换，如果d较大，中间会有一定范围的元素是无法交换的。因此，如果这中间的元素不是已经排好的话，必然不可排序。

算是结论题吧，很难说证明，暂时没想出它的构造方案。简单来说，如果所有元素都可以进行交换，那么这个序列必然是可排序的

#include 
#define yes puts("yes");
#define inf 0x3f3f3f3f
#define ll long long
#define linf 0x3f3f3f3f3f3f3f3f
#define debug(x) cout<<"> "<< x< PII;
const int N =10 + 1e5 ,mod=1e9 + 7;
int n,x;
int a[N],b[N];
void solve()
{    
    cin>>n>>x;
    for(int i=1;i<=n;i++)cin>>a[i],b[i] = a[i];
    sort(b+1,b+1+n);
    int l = n - x + 1, r = x; 
    if(l>r){
        cout<<"YESn";
        return;
    }
    for(int i=l;i<=r;i++){
        if(a[i]!=b[i]){
            cout<<"NOn";
            return;
        }
    }
    cout<<"YESn";
}
signed main()
{
    ios::sync_with_stdio();cin.tie();cout.tie();

    int T;cin>>T;
    while(T--)
        solve();

    return 0;
}

给定一棵树，树上节点存有一些值，现在最大可以删除k-1条边，把这棵树分为多棵树，求是否找到可以在切割后，使得每棵子树的异或和的异或和等于整棵树的异或和

kep point: 异或和计算的性质 x^xx = x

• 首先如果整棵树的异或和为零，那么我们一定可以找出两棵树的异或和是相等的（x^x=0)
• 如果整棵树的异或和不是零，如果我们可以把这棵树至少分为三棵树，那么一定可行，反之不行（因为如果不可能找到两棵树的异或和相等——这和x^x=0矛盾。）
• 那么只要树上dfs，处理出每棵子树的异或和，如果遇到和整棵树的异或和相等，就把这棵树剪掉，统计一个减去的次数即可。

#include 
#define yes puts("yes");
#define inf 0x3f3f3f3f
#define ll long long
#define linf 0x3f3f3f3f3f3f3f3f
#define debug(x) cout<<"> "<< x< PII;
const int N =10 + 1e5 ,mod=1e9 + 7;
vector >tr;
int sum,tot;
vectora;
int dfs(int u,int fa){//dfs返回子树的异或和
    int s = a[u];//子树异或和
    for(vector::iterator v=tr[u].begin();v!=tr[u].end();v++){
        if(*v!=fa){
            s^=dfs(*v,u);
        }
    }
    if(s == sum){
        tot++;
        return 0;// 返回0，模拟减去  
        //之所以减去而不保留，是防止重复计算，先找到的满足的子树一定是最小的子树
        //我们目标是尽可能多的减去，最先找到的一定是最小的子树，所以不用担心减去是否影响其他子树的异或和
    }
    return s;
}
void solve()
{    
    tot = 0;
    sum = 0;
    int n,k;
    scanf("%d%d",&n,&k);
    a.clear(),a.resize(n+1);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]),sum^=a[i];
    tr.clear();
    tr.resize(n+1);
    for(int i=1;i>u>>v;
        tr[u].push_back(v);
        tr[v].push_back(u);
    }
    // x^x=0 the tree must be cut by one step
    if(!sum){
        puts("YES");
        return;
    }
    // find x^x^x = x
    dfs(1,-1);
    if(k>=3 && tot >=2)puts("YES");
    else puts("NO");
}
// 一些有的没的，才发现子树和子树其实是挺独立的东西，独立而相似，相对而言，图彼此之间不怎么独立，所以在解决树的问题，才可以频繁的使用递归解决

signed main()
{
    ios::sync_with_stdio();cin.tie();cout.tie();

    int T;cin>>T;
    while(T--)
        solve();

    return 0;
}

递归的考虑问题，x=x^xx,子树又可以拆分，直到拆到不可再拆，dfs找的就是这些个不可再拆的子树们。所以统计的子树个数一定是理论上的最大值，而这些小零件递归回去，也一定可以还原三棵大子树。

万恶的交互题。
给出一棵树，每次可以发起询问：某一些节点通路的gcd的最大值是多少？ ，现在让你进行最大12次的询问找到路径权值最大的那条路径。

kep point：树上二分

• 首先，可以通过询问整棵树的通路gcd，得到要寻找的最大权值（gcd总是要比最大权值小的，而单条边的gcd是它本身）
• 用欧拉序处理出树上节点，对这个数组进行二分查找最大值即可。

#include 
#define yes puts("yes");
#define inf 0x3f3f3f3f
#define linf 0x3f3f3f3f3f3f3f3f
#define ll long long
#define ull unsigned long long
#define debug(x) cout<<"> "<< x< PII;
const int N =10 + 1e5, mod = 1e9 + 7;

void solve()
{    
    int n;
    cin>>n;
    vector >tr(n);
    for(int i=0;i>a>>b;
        a--,b--;
        tr[a].push_back(b);
        tr[b].push_back(a);
    }

    vectorord;
    function dfs = [&](int u,int fa){
        ord.push_back(u);
        for(auto v:tr[u]){
            if(v!=fa){
                dfs(v,u);
                ord.push_back(u);
            }
        }
    };
    dfs(0,-1);

    auto ask = [&](int l,int r){
        vectorv;
        for(int i=l;i<=r;i++){
            v.push_back(ord[i]);
        }
        sort(v.begin(),v.end());
        v.resize(unique(v.begin(),v.end())-v.begin());
        cout<<"? "<>res;
        return res;
    };

    int l = 0,r = ord.size() - 1;
    int res = ask(l,r);
    while(r - l > 1){
        int mid = l+r>>1;
        if(ask(mid,r) == res) l = mid;
        else r = mid;
    }
    cout<<"! "<