A. Palindromic Indices

英语不好，以为是问可以删除的下标，还开了个问题。。

容易发现对于回文串，删除中间元素后仍然为回文串，所以方案数即为与中间元素等价的元素个数，所以从中间找出与中间元素相同的连续区间长度即为答案

B. AND Sorting

我们只需要关注不在应在位置的元素即可。对于这些元素的与结果肯定是一个答案，接下来只需要考虑是否有比该值大的答案。

容易推理出如果存在，则必定有部分元素不能被交换，所以输出与结果即可。

C. LIS or Reverse LIS?

题目说明了可以将元素任意放置，我们可以先考虑排序去重得到最长的LIS。

然后我们思考如何使得答案最大，注意到如果某元素的数量大于1时，他可以在反转和正序的LIS都有1的贡献，并且对于一个数量为1的元素亦可做到该贡献。

所以答案就是（去重后的元素数量+数量大于1 的元素数量+1）/2

D. Circular Spanning Tree

构造题，首先先特判一些NO的情况，如题目中的”10″，然后以及考虑到的全为”0″的情况

然后就是如何构造的问题了。注意到’0’的节点与’1’的节点相连后，’1’的节点可以舍去，而’0’的节点会等价于’1’的节点。所以我们先找到为’1’的节点坐标，然后维护一个栈，遇到’1’就放入下标，遇到’0’就弹出构造一个答案，并把当前节点下标放入栈中。

最后就剩下一些等价’1’的节点，思考到如果栈内元素的个数为奇数，则不能构造答案，应该直接输出NO，否则取出一个元素，然后将剩余元素与其相连即可。

E. Unordered Swaps

assert害死人，RE这么多。。。。

首先从排列中每个不在应在位置的元素会构成一个环，所以我们可以先bfs求出每个元素的层数，每组元素的个数。

然后对接下来的交换对建一个临接链表，用map存id。

然后对每个点遍历一遍边，计算出相对层数并将结果与id存入vector后排序，从第二个开始每个点对id度数加一(不如说是：受约束计数变量，因为我们仅可以先执行对两点均为最相邻的步骤，即为0)

然后遍历点对id，将度数为0的存入队列中，循环输出答案即可。

Code:

A

cin>>tt;
    f(sb,1,tt){
        cin>>n>>s;
        s=' '+s;
        char c=s[(n+1)/2];
        int l=(n+1)/2,r=(n+1)/2;
        while(s[l]==c)l-=1;
        while(s[r]==c)r+=1;
        //cout<<r<<"::"<<l<<"\n";
        cout<<r-l-1<<'\n';
    }

B

LL tt,n;
int a[(int)2e5+9];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>tt;
    f(sb,1,tt){
        cin>>n;
        f(i,0,n-1)cin>>a[i];
        vi ans;
        f(i,0,n-1){
            if(a[i]!=i)ans.push_back(a[i]);
        }
        int res=ans[0];
        for(auto it:ans)res&=it;
        cout<<res<<"\n";
    }
    return 0;
}

C

LL tt,n;
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>tt;
    f(sb,1,tt){
        map<int,int> cnt;
        cin>>n;
        vi v(n);
        for(auto &it:v)cin>>it,cnt[it]+=1;
        sort(all(v));
        auto it=unique(all(v));
        LL lis=it-v.begin(),cf=0;
        for(auto i=v.begin();i!=it;++i){
            if(cnt[*i]>1)cf+=1;
        }
        cout<<(lis+cf+1)/2<<"\n";
    }
    return 0;
}

D

LL tt, n;
string s;
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> tt;
    f(sb, 1, tt)
    {
        cin >> n >> s;
        int cn1 = 0,st=0;
        for (auto it : s)
            if (it == '1')
                cn1 += 1;
        if( (n - cn1 == 1 && (cn1 & 1))||cn1==0)
        {
            cout << "NO\n";
            continue;
        }
        while(s[st]=='0')st+=1;
        vector<pii>ans;
        stack<int> s1;
        for(int i=0;i<n;++i){
            if(s[(st+i)%n]=='1'){
                s1.push((st+i)%n);
            }else {
                ans.push_back({s1.top(),(st+i)%n});
                s1.pop();
                s1.push((st+i)%n);
            }
        }
        if(s1.size()&1){
            cout<<"NO\n";
            continue;
        }
        int hd=s1.top();
        s1.pop();
        while(!s1.empty()){
            ans.push_back({s1.top(),hd});
            s1.pop();
        }
        cout<<"YES\n";
        for(auto [aa,bb]:ans){
            cout<<aa+1<<" "<<bb+1<<"\n";
        }
    }
    return 0;
}

E

#include <algorithm>
#include <bitset>
#include <map>
#include <vector>
#include <string>
#include <cstring>
#include <iostream>
#include <ctime>
#include <cmath>
#include <stack>
#include <set>
#include <queue>
#include <array>

using namespace std;

const double eps = 1e-10;
const double pi = 3.1415926535897932384626433832795;
const double eln = 2.718281828459045235360287471352;

#define f(i, a, b) for (int i = a; i <= b; i++)
#define LL long long
#define IN freopen("in.txt", "r", stdin)
#define OUT freopen("out.txt", "w", stdout)
#define scan(x) scanf("%d", &x)
#define mp make_pair
#define pb push_back
#define sqr(x) (x) * (x)
#define pr1(x) printf("Case %d: ", x)
#define pn1(x) printf("Case %d:\n", x)
#define pr2(x) printf("Case #%d: ", x)
#define pn2(x) printf("Case #%d:\n", x)
#define lowbit(x) (x & (-x))

#define fi first
#define se second
#define sz(x) int((x).size())
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define summ(a) (accumulate(all(a), 0ll))

typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;

LL n, m;
LL fa[(int)2e5 + 9], a[(int)2e5 + 9], sz[(int)2e5 + 9], dep[(int)2e5 + 9], deg[(int)2e5 + 9];
map<array<int,2>, int> id;

bitset<(int)2e5 + 9> vis;
vector<int> adj[(int)2e5 + 9], andj[(int)2e5 + 9];
vector<pii> an[(int)2e5 + 9];

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> n >> m;
    f(i, 1, n)
    {
        cin >> a[i];
        sz[i] = 1;
    }
    f(i, 1, n)
    {
        if (a[i] != i && !vis[i])
        {
            int cs = 0;
            dep[i] = ++cs;
            vis[i] = 1;
            for (int j = a[i]; !vis[j]; j = a[j])
            {
                vis[j] = 1, dep[j] = ++cs, fa[j] = i;
            }
            fa[i] = -cs;
        }
    }
    for (int i = 1, x, y; i <= m; ++i)
    {
        cin >> x >> y;
        id[{x, y}] = id[{y, x}] = i;
        adj[x].push_back(y), adj[y].push_back(x);
    }
    f(i, 1, n)
    {
        int sz;
        sz = fa[i] < 0 ? -fa[i] : -fa[fa[i]];
        for (auto it : adj[i])
        {
            int u = (dep[it] - dep[i] + sz) % sz;

            an[i].push_back({u, id[{i, it}]});
        }
        sort(all(an[i]));
        for (int j = 1; j < an[i].size(); ++j)
        {
            deg[an[i][j].second] += 1;
            andj[an[i][j - 1].second].pb(an[i][j].second);
        }
    }
    queue<int> q;
    f(i, 1, m)
    {
        if (!deg[i])
            q.push(i);
    }
    while (!q.empty())
    {
        auto p = q.front();
        q.pop();
        cout << p << " ";
        for (auto it : andj[p])
        {
            deg[it] -= 1;
            if (!deg[it])
                q.push(it);
        }
    }

    return 0;
}