2020 Multi-University Training Contest 8 部分题解

于 2021-03-25 20:03:30 发布
阅读量338 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Irving0323/article/details/115172597
版权

A - Auto-correction

留坑。

 

B - Breaking Down News

dp[i]表示前i个数在合法划分情况下的最大值。

转移方程：dp[i] = max(dp[i] , dp[j] + [a[i] > a[j]] - [a[j] - a[i]])，其中i - R \leqslant j \leqslant i - L，a[i]是前缀和。

考虑权值线段树优化dp，分类讨论如下：

  • a[j] > a[i]，dp[i] = max(dp[i] , dp[j] - 1)
  • a[j] < a[i]，dp[i] = max(dp[i] , dp[j] + 1)
  • a[j] = a[i]，dp[i] = max(dp[i] , dp[j])

对于i - R \leqslant j \leqslant i - L这个条件需要单调队列维护。

因为我常数太大了，需要手写deque，快读才能过。

#include<bits/stdc++.h>
using namespace std ;
const int maxn = 2e6 + 10 ;
int mx[maxn << 2] ;
vector<int> v[maxn] ;
int l[maxn] , r[maxn] ;
int ls(int x)
{
   return x << 1 ;
}
int rs(int x)
{
   return x << 1 | 1 ;
}
void build(int id , int l , int r)
{
   if(l == r){mx[id] = -1e9 ; return ;}
   int mid = (l + r) >> 1 ;
   build(ls(id) , l , mid) ;
   build(rs(id) , mid + 1 , r) ;
   mx[id] = max(mx[ls(id)] , mx[rs(id)]) ;
}
void update(int id , int l , int r , int x , int y)
{
   int mid = (l + r) / 2 ;
   if(l == r && l == x){mx[id] = y ; return ;}
   if(x <= mid)  update(ls(id) , l , mid , x , y) ;
   else  update(rs(id) , mid + 1 , r , x , y) ;
   mx[id] = max(mx[ls(id)] , mx[rs(id)]) ;
}
int query(int id , int l , int r , int x , int y)
{
   int ans = -1e9 ;
   int mid = (l + r) / 2 ;
   if(y < x || y < l || x > r)  return -1e9 ; //不合法的询问
   if(x <= l && r <= y)  return mx[id] ;
   if(x <= mid)  ans = max(ans , query(ls(id) , l , mid , x , y)) ;
   if(y > mid)  ans = max(ans , query(rs(id) , mid + 1 , r , x , y)) ;
   return ans ;
}
template<typename T> void read(T &res)  //read(n) ;
{
    bool flag = 0 ;
    char ch ;
    while(!isdigit(ch = getchar()))(ch == '-') && (flag = 1) ;
    for(res = ch - 48 ; 
    isdigit(ch = getchar()) ; 
    res = (res << 1) + (res << 3) + ch - 48) ;
    flag && (res = -res) ;
}
int main()
{
    //std::ios::sync_with_stdio(false) , cin.tie(0) ;
    int T ;
    read(T) ;
    while(T --)
    {
        int n , L , R ;
        read(n) ;
        read(L) ;
        read(R) ;
        vector<int> a(n + 1 , 0) ;
        for(int i = 1 ; i <= n ; i ++)  read(a[i]) , a[i] += a[i - 1] ;
        int m = n * 2 + 1 ; //[-n , n] -> [1 , 2 * n + 1]
        build(1 , 1 , m) ;
        for(int i = 1 ; i <= m ; i ++)  v[i].clear() , l[i] = 0 , r[i] = -1 ;
        vector<int> dp(n + 1 , -1e9) ;
        dp[0] = 0 ;
        // i - R <= j <= i - L
        // a[j] > a[i]  dp[i] = max(dp[j] - 1)
        // a[j] < a[i]  dp[i] = max(dp[j] + 1)
        // a[j] = a[i]  dp[i] = max(dp[j])
        auto change = [&](int u)
        {
            return u + n + 1 ;
        } ;
        auto del = [&](int i)
        {
            if(i < 0 || dp[i] < -1e8)  return ;
            int t = change(a[i]) ;
            if(l[t] <= r[t] && v[t][l[t]] == i)  l[t] ++ ;
            if(l[t] > r[t])  update(1 , 1 , m , t , -1e9) ;
            else  update(1 , 1 , m , t , dp[v[t][l[t]]]) ;
        } ;
        auto add = [&](int i)
        {
            if(i < 0 || dp[i] < -1e8)  return ;
            int t = change(a[i]) ;
            while(l[t] <= r[t] && dp[v[t][r[t]]] <= dp[i])  r[t] -- ;
            if(r[t] + 1 <= (int)v[t].size() - 1)  r[t] ++ , v[t][r[t]] = i ;
            else  r[t] ++ , v[t].push_back(i) ;
            update(1 , 1 , m , t , dp[v[t][l[t]]]) ;
        } ;
        auto ask = [&](int i)
        {
            dp[i] = max(dp[i] , query(1 , 1 , m , 1 , change(a[i] - 1)) + 1) ;
            dp[i] = max(dp[i] , query(1 , 1 , m , change(a[i] + 1) , m) - 1) ;
            dp[i] = max(dp[i] , query(1 , 1 , m , change(a[i]) , change(a[i]))) ;
        } ;
        for(int i = 1 ; i <= n ; i ++)
        {
            del(i - R - 1) ;
            add(i - L) ;
            ask(i) ;
        }
        printf("%d\n" , dp[n]) ;
    }
    return 0 ;
}

 

C - Clockwise or Counterclockwise

温暖的签到题。

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll cross(int x1, int y1, int x2, int y2, int x3, int y3)
{
    return 1ll*(x2-x1)*(y3-y1) - 1ll*(y2-y1)*(x3-x1);
}
void solve()
{
    int x1, y1, x2, y2, x3, y3;
    scanf("%d%d%d%d%d%d", &x1, &y1, &x2, &y2, &x3, &y3);
    if(cross(x1, y1, x2, y2, x3, y3)<0) puts("Clockwise");
    else puts("Counterclockwise");
}
int main()
{
    int _; scanf("%d", &_);
    while(_--) solve();
    return 0;
}

 

D - Discovery of Cycles

定义R[i]表示[i,R[i]]区间有环且R[i]是相对于i的最小值。

显然R[i]是递增的，可以双指针计算R。

环可以通过LCT维护。

#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 5;
struct LCT
{
    int ch[N][2], fa[N], rev[N];
    int id[N], mn[N];
    void clear(int x)
    {
        ch[x][0] = ch[x][1] = fa[x] = rev[x] = 0;
        id[x] = mn[x] = N;
    }
    void init(int n) { for(int i=1; i<=n; i++) clear(i); }
    #define rs(x) (ch[fa[x]][1]==x)
    int notrt(int x) { return ch[fa[x]][0]==x || ch[fa[x]][1]==x; }
    void up(int x)
    {
        mn[x] = id[x];
        if(ch[x][0]) mn[x] = min(mn[x], mn[ch[x][0]]);
        if(ch[x][1]) mn[x] = min(mn[x], mn[ch[x][1]]);
    }
    void setrev(int x)
    {
        swap(ch[x][0], ch[x][1]);
        rev[x] ^= 1;
    }
    void down(int x)
    {
        if(rev[x])
        {
            if(ch[x][0]) setrev(ch[x][0]);
            if(ch[x][1]) setrev(ch[x][1]);
            rev[x] = 0;
        }
    }
    void downall(int x)
    {
        if(notrt(x)) downall(fa[x]);
        down(x);
    }
    void rotate(int x)
    {
        int y = fa[x], z = fa[y], k = rs(x), w = rs(y);
        if(notrt(y)) ch[z][w] = x;
        ch[y][k] = ch[x][!k]; fa[ch[x][!k]] = y;
        ch[x][!k] = y; fa[y] = x; fa[x] = z;
        up(y); up(x); up(z);
    }
    void splay(int x)
    {
        downall(x);
        for(int f=fa[x]; f=fa[x], notrt(x); rotate(x))
            if(notrt(f)) rotate(rs(x) == rs(f) ? f : x);
    }
    void access(int x)
    {
        for(int y=0; x; x=fa[y=x])
            splay(x), ch[x][1] = y, up(x);
    }
    void makeroot(int x)
    {
        access(x); splay(x);
        setrev(x);
    }
    int findroot(int x)
    {
        access(x); splay(x);
        while(ch[x][0]) down(x), x = ch[x][0];
        splay(x);
        return x;
    }
    void split(int x, int y)
    {
        makeroot(x);
        access(y); splay(y);
    }
    void link(int x, int y)
    {
        makeroot(x);
        fa[x] = y;
    }
    void cut(int x, int y)
    {
        split(x, y);
        fa[x] = ch[y][0] = 0;
        up(y);
    }
}T;
struct edge 
{ 
    int u, v; 
}e[N];
int n, m, q, pre[N];
int fa[N];
void init(int n) { iota(fa+1, fa+n+1, 1); }
int find(int x) { return x==fa[x] ? x : fa[x] = find(fa[x]); }
void merge(int x, int y)
{
    int fx = find(x), fy = find(y);
    if(fx!=fy) fa[fx] = fy;
}
void solve()
{   
    scanf("%d%d%d", &n, &m, &q);
    T.init(n+m);
    init(n);
    for(int i=1; i<=m; i++)
    {
        T.mn[n+i] = T.id[n+i] = i;
        scanf("%d%d", &e[i].u, &e[i].v);
        if(find(e[i].u)!=find(e[i].v))
        {
            T.link(e[i].u, n+i); T.link(e[i].v, n+i);
            merge(e[i].u, e[i].v);
            pre[i] = 1;
        } 
        else
        {
            T.split(e[i].u, e[i].v);
            int id = T.mn[e[i].v];
            T.cut(e[id].u, e[id].v);
            pre[i] = id + 1;
            T.link(e[i].u, n+i); T.link(e[i].v, n+i);
        }
        pre[i] = max(pre[i], pre[i-1]);
    }
    int lst = 0;
    for(int i=1; i<=q; i++)
    {
        int l, r; scanf("%d%d", &l, &r);
        int k1 = (l^lst)%m + 1;
        int k2 = (r^lst)%m + 1;
        l = min(k1, k2), r = max(k1, k2);
        if(pre[r]>l) puts("Yes"), lst = 1;
        else puts("No"), lst = 0;
    }
}
int main()
{
    int _; scanf("%d", &_);
    while(_--) solve();
    return 0;
}

 

E - Easy NPC Problem

留坑。

 

F - Fluctuation Limit

温暖的签到题。

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, k, l[N], r[N], x[N];
void solve()
{
    scanf("%d%d", &n, &k);
    for(int i=1; i<=n; i++) scanf("%d%d", l+i, r+i);
    for(int i=2; i<=n; i++)
    {
        int pl = l[i-1] - k, pr = r[i-1] + k;
        l[i] = max(l[i], pl);
        r[i] = min(r[i], pr);
        if(l[i]>r[i]) { puts("NO"); return; }
    }
    puts("YES");
    x[n] = l[n];
    for(int i=n-1; i>=1; i--)
    {
        int pl = max(x[i+1]-k, l[i]);
        x[i] = pl;
    }
    for(int i=1; i<=n; i++) printf("%d%c", x[i], " \n"[i==n]);
}
int main()
{
    int _; scanf("%d", &_);
    while(_--) solve();
    return 0;
}

 

G - Gaming of Co-prime Disallowance

迷一样的题意，不知道在说啥，只好自己脑补了另一个题意。

按照下面题意写代码才能过：

取过k张牌，如果k张牌的gcd=1，那么取第k张牌的人赢。
1.n个数的gcd>1，问你先手赢的概率
2.n个数的gcd=1，问你后手赢的概率

其实主要问题是怎么算一方赢的概率，不妨设为先手。

首先一个不超过10w的数最多有6个不同质因子。枚举第一张牌，对于剩下所有数的质因子要么是第一张牌中的质因子，要么不是，考虑状压枚举。

dp[i][j]表示选择了i张牌，且质因子状压是j的概率。通过这个dp可以算出答案。

考虑到精度的问题，需要边加边除。不然你直接除个n!直接凉凉。

具体转移看代码吧，细节有一丢丢麻烦。

#include<bits/stdc++.h>
using namespace std ;
typedef double db ;
const int maxn = 1e5 + 10 ;
const db eps = 1e-6 ;
int cnt = 0 ;
bool vis[maxn] ;
int prime[maxn] ;
void get_prime(int up) //??ɸ
{
    memset(vis , 0 , sizeof(vis)) ;
    vis[1] = 1 ;
    for(int i = 2 ; i <= up ; i ++)
    {
        if(!vis[i]) 
        prime[++ cnt] = i ;
        for(int j = 1 ; j <= cnt && i * prime[j] <= up ; j ++)
        {
            vis[i * prime[j]] = 1 ;
            if(i % prime[j] == 0) break ;
        }
    }
}
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    int T ;
    cin >> T ;
    get_prime(100000) ;
    while(T --)
    {
        int n ;
        cin >> n ;
        vector<int> a(n + 1) ;
        for(int i = 1 ; i <= n ; i ++)  cin >> a[i] ;
        int d = a[1] ;
        for(int i = 2 ; i <= n ; i ++)  d = __gcd(d , a[i]) ;
        vector<vector<int>> p(n + 1) ;
        auto init = [&]()
        {
            for(int i = 1 ; i <= n ; i ++)
            {
                int tmp = a[i] ;
                for(int j = 1 ; prime[j] * prime[j] <= a[i] ; j ++)
                {
                    if(a[i] % prime[j] == 0)
                    {
                        p[i].push_back(prime[j]) ;
                        while(a[i] % prime[j] == 0)  a[i] /= prime[j] ;
                    }
                }
                if(a[i] > 1)  p[i].push_back(a[i]) ;
                a[i] = tmp ;
            }
        } ;
        init() ; 
        db ans = 0.0 ;
        auto cal = [&](int s)
        {
            if(a[s] == 1)  return 1.0 / n ;
            int num = (1 << p[s].size()) ;
            vector<vector<db>> dp(n + 1 , vector<db>(num , 0.0)) ;
            vector<int> c(num , 0) , d(num , 0) , e(num , 0) ;
            vector<vector<int>> f(num , vector<int>(num , 0)) ;
            db res = 0.0 ;
            for(int i = 1 ; i <= n ; i ++)
            {
                int t = 0 ;
                for(int j = 0 ; j < (int)p[s].size() ; j ++)
                {
                    if(a[i] % p[s][j] == 0)  t ^= (1 << j) ;
                }
                c[t] ++ ;
            }
            for(int i = 0 ; i < num ; i ++)  for(int j = 0 ; j < num ; j ++)
                if((i & j) == i)  d[i] += c[j] ;
            for(int i = 0 ; i < num ; i ++)  for(int j = 0 ; j < num ; j ++)
                if((i & j) == 0)  e[i] += c[j] ;
            for(int i = 0 ; i < num ; i ++)  for(int j = 0 ; j < num ; j ++)  for(int k = 0 ; k < num ; k ++)
                if((i & j) == k)  f[i][k] += c[j] ;
            dp[1][num - 1] = 1.0 / n ;
            for(int i = 1 ; i <= n - 1 ; i ++)
            {
                for(int j = 1 ; j < num ; j ++)
                {
                    for(int k = j ; k ; k = (k - 1) & j)
                    {
                        if(k == j && d[k] > i)  dp[i + 1][k] += dp[i][j] * (d[k] - i) / (n - i) ;
                        else if(k != j && f[j][k])  dp[i + 1][k] += dp[i][j] * f[j][k] / (n - i) ;
                    }
                    if((i + 1) % 2 == 1)  res += dp[i][j] * e[j] / (n - i) ;
                }
            }
            return res ;
        } ;
        if(d > 1)
        {
            if(n % 2 == 1)  cout << "1.000000000\n" ;
            else  cout << "0.000000000\n" ;
        }
        else
        {
            for(int i = 1 ; i <= n ; i ++)  ans += cal(i) ;
            cout << fixed << setprecision(9) << 1 - ans << '\n' ;
        }
        
    }
    return 0 ;
}

 

H - Hexagon

需要发现60^{\circ},60^{\circ},120^{\circ}交替出现的规律才会很好写。不过强力队友没发现此规律硬写三个小时也通过了。膜！

#include<bits/stdc++.h>
using namespace std;
#define M 1005
string ans;
int rx[]={0,1,1,0,-1,-1};
int ry[]={2,1,-1,-2,-1,1};
int mark[M<<1][M<<1];
int kase;
bool In(int x,int y,int n){
	return x<=n&&x>=-n&&x+y<=2*n&&x+y>=-2*n&&x-y<=2*n&&x-y>=-2*n;
}
bool check(int x,int y,int n){
	if(x==n||x==-n||x+y==2*n||x+y==-2*n||x-y==2*n||x-y==-2*n)return 1;
	return 0;
}
bool Near(int x,int y,int prex,int prey){
	for(int i=0;i<6;i++){
		if(x+rx[i]==prex&&y+ry[i]==prey)return 1;
	}
	return 0;
}
void move(int &x,int &y,int n){
	if(check(x,y,n)){
		for(int i=0;i<6;i++){
			int X=x+rx[i],Y=y+ry[i];
			if(In(X,Y,n)&&mark[X+M][Y+M]!=kase&&!check(X,Y,n)){
				ans+=(i+1+'0');
				x=X;y=Y;
				return;
			}
		}
		for(int i=0;i<6;i++){
			int X=x+rx[i],Y=y+ry[i];
			if(In(X,Y,n)&&mark[X+M][Y+M]!=kase&&check(X,Y,n)){
				ans+=(i+1+'0');
				x=X;y=Y;
				return;
			}
		}
	}
	else {
		for(int i=0;i<6;i++){
			int X=x+rx[i],Y=y+ry[i];
			if(In(X,Y,n)&&mark[X+M][Y+M]!=kase&&check(X,Y,n)){
				ans+=(i+1+'0');
				x=X;y=Y;
				return;
			}
		}
		for(int i=0;i<6;i++){
			int X=x+rx[i],Y=y+ry[i];
			if(In(X,Y,n)&&mark[X+M][Y+M]!=kase&&!check(X,Y,n)){
				ans+=(i+1+'0');
				x=X;y=Y;
				return;
			}
		}
	}
}
void solve(){
	int n;
	++kase;
	scanf("%d",&n);
	ans="";
	string tmp="612423534645156261";
	if(n&1){
		int x=0,y=0;
		mark[0+M][0+M]=kase;
		for(int i=3;i<=n;i+=2){
			ans+="61";
			mark[x-1+M][y+1+M]=kase;
			x--;y+=3;
			mark[x+M][y+M]=kase;
			int m=(i+i-3)*6;
			while(m--){
				move(x,y,i-1);
				mark[x+M][y+M]=kase;
			}
		}
		for(int i=0;i<18;i++)ans[i]=tmp[i]; 
	}
	else{
		ans+="134561";
		int x=-1,y=1;
		mark[0+M][0+M]=kase;
		mark[0+M][2+M]=kase;
		mark[1+M][1+M]=kase;
		mark[1+M][-1+M]=kase;
		mark[0+M][-2+M]=kase;
		mark[-1+M][-1+M]=kase;
		mark[-1+M][1+M]=kase;
		for(int i=4;i<=n;i+=2){
			ans+="61";
			mark[x-1+M][y+1+M]=kase;
			x--;y+=3;
			mark[x+M][y+M]=kase;
			int m=(i+i-3)*6;
			while(m--){
				move(x,y,i-1);
				mark[x+M][y+M]=kase;
			}
		}
	}
	cout<<ans<<'\n';
}
int main(){
	int T;
	scanf("%d",&T);
	while(T--)solve(); 
	return 0;
}

 

I - Isomorphic Strings

枚举k，对于s[1..k]的k个循环同构串进行hash，然后枚举s[k+1..2*k],...,s[n-k+1..n]是否是s[1..k]的循环同构串。

手写hash可以通过。或者大力卡常。

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
using namespace __gnu_pbds;
using ull = uint64_t;
const ull base = 131, mod = 1e9 + 7;
const int N = 5e6 + 5;
const int M = 2174729;
struct HashSet
{
    struct node { int next; ull k; }e[M+5];
    int head[M], st[N], tp, sz;
    int f(ull k) { return k % M; }
    void clear() { sz = 0; while(tp) head[st[tp--]] = 0; }
    bool get(ull k) 
    {
        for(int p = head[f(k)]; p; p = e[p].next)
            if(e[p].k==k) return true;
        return false;
    }
    void ins(ull k)
    {
        if(get(k)) return;
        int t = f(k);
        e[++sz] = {head[t], k};
        head[t] = sz; st[++tp] = t;
    }
}st;
int n;
char s[N];
ull pw[N], h[N];
void init()
{
    pw[0] = 1;
    for(int i=1; i<=n; i++)
    {
        h[i] = (h[i-1]*base + s[i])%mod;
        pw[i] = pw[i-1]*base%mod;
    }
}
ull get(int l, int r) { return (h[r]-h[l-1]*pw[r-l+1]%mod+mod)%mod; }
bool check(int k)
{
    static ull ht[N];
    for(int i=1; i<=k; i++) ht[i] = (ht[i-1]*base + s[i])%mod;
    for(int i=1; i<=k; i++) ht[i+k] = (ht[i+k-1]*base + s[i])%mod;
    st.clear();
    for(int l=1; l<=k; l++)
    {
        int r = l + k - 1;
        ull cur = (ht[r]-ht[l-1]*pw[r-l+1]%mod+mod)%mod;
        st.ins(cur);
    }
    for(int l=1; l<=n; l+=k) if(!st.get(get(l, l+k-1))) return false;
    puts("Yes");
    return true;
}
void solve()
{
    scanf("%d%s", &n, s+1);
    init();
    if(n==1) { puts("No"); return; }
    bool same = 1;
    for(int i=2; i<=n; i++) same &= (s[i]==s[i-1]);
    if(same) { puts("Yes"); return; }
    for(int k=2; k*k<=n; k++)
    {
        if(n%k==0) 
        {
            if(check(k)) return;
            if(k*k!=n && check(n/k)) return; 
        }
    }
    puts("No");
}
int main()
{
    int _; scanf("%d", &_);
    while(_--) solve();
    return 0;
}

 

J - Jumping on a Cactus

留坑。

 

K - Kidnapper's Matching Problem

设S构成的线性基是B，x消除B中的位后剩下x^{'}，y消除B中的位后剩下y^{'}。

结论是x\oplus y \in 2^S_{\oplus}\Leftrightarrow x^{'}=y^{'}。

证明x^{'}=y^{'} \Rightarrow x\oplus y \in 2^S_{\oplus}：x\oplus y = x^{'} \oplus y^{'} \oplus t，其中t可以被B表示。因为x^{'}=y^{'}，则x\oplus y=t，即x\oplus y \in 2^S_{\oplus}。

证明x\oplus y \in 2^S_{\oplus} \Rightarrow x^{'}=y^{'}：考虑反证，即证明x^{'}\neq y^{'} \Rightarrow x\oplus y \notin 2^S_{\oplus}。x^{'},y^{'}都有B无法表示的位，因为x^{'}\neq y^{'}，则x\oplus y有B无法表示的位，即x\oplus y \notin 2^S_{\oplus}。

然后把a,b在线性基中跑一遍后，再做一遍kmp即可。

#include<bits/stdc++.h>
using namespace std ;
const int maxn = 2e5 + 10 ;
const int mod = 1e9 + 7 ;
struct Linear_base
{
    bool zero ;
    int cnt ;
    int b[35] , p[35] ;
    void init()
    {
        zero = 0 ;
        cnt = 0 ;
        memset(b , 0 , sizeof(b)) ;
        memset(p , 0 , sizeof(p)) ;
    }
    bool insert(int x)
    {
        for(int i = 29 ; i >= 0 ; i --)
        if(x & (1 << i))
        {
            if(b[i])  x ^= b[i] ;
            else  
            {
                b[i] = x ;
                return 1 ;
            }
        }
        zero = 1 ;
        return 0 ;
    }
    int get(int x)
    {
        for(int i = 29 ; i >= 0 ; i --)
            if(x & (1 << i))
            {
                if(b[i])  x ^= b[i] ;
            }
        return x ;
    }
} linear_base ;
int qpow(int a , int b) //快速幂
{
    if(b < 0)  return 0 ;
    int ans = 1 ; 
    a %= mod ;
    while(b)
    {
        if(b & 1)  ans = (1ll * ans * a) % mod ;
        b >>= 1 , a = (1ll * a * a) % mod ;
    }
    return ans % mod ;
}
struct KMP
{
    int s1[maxn] , s2[maxn] ;
    int len1 , len2 ;
    int nxt[maxn] ;
    void get_nxt(vector<int> a , vector<int> b)
    { 
        nxt[0] = -1 ;  
        int j = 0 , k = -1 ;
        len1 = a.size() - 1 ;
        len2 = b.size() - 1 ;
        for(int i = 0 ; i < len1 ; i ++)  s1[i] = a[i + 1] ;
        for(int i = 0 ; i < len2 ; i ++)  s2[i] = b[i + 1] ;
        while(j < len2)  
        {  
            if(k == -1 || s2[j] == s2[k])  j ++ , k ++ , nxt[j] = k ;  
            else  k = nxt[k] ;  
        } 
    } 
    void solve()
    {
        int ans = 0 ;
        int i = 0 , j = 0 ;
        while(i < len1)
        {
            if(j == -1 || s1[i] == s2[j])  i ++ , j ++ ;
            else  j = nxt[j] ;
            if(j == len2)  
            {
                ans += qpow(2 , i - len2) ;
                ans %= mod ;
                j = nxt[j] ;
            }
        }
        cout << ans << '\n' ;
    }
} kmp ;
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    int T ;
    cin >> T ;
    while(T --)
    {
        int n , m , k ;
        cin >> n >> m >> k ;
        vector<int> a(n + 1) , b(m + 1) , c(k + 1) ;
        for(int i = 1 ; i <= n ; i ++)  cin >> a[i] ;
        for(int i = 1 ; i <= m ; i ++)  cin >> b[i] ;
        for(int i = 1 ; i <= k ; i ++)  cin >> c[i] ;
        linear_base.init() ;
        for(int i = 1 ; i <= k ; i ++)  linear_base.insert(c[i]) ;
        for(int i = 1 ; i <= n ; i ++)  a[i] = linear_base.get(a[i]) ;
        for(int i = 1 ; i <= m ; i ++)  b[i] = linear_base.get(b[i]) ;
        kmp.get_nxt(a , b) ;
        kmp.solve() ;
    }
    return 0 ;
}

 

L - Linuber File System

dp[i][j]表示节点i的所有祖先的修改的权值和是j的以i为根的子树的最小操作次数。

其中j只能是若干个l[i],r[i]及0中的一个，如果不是，可以在不增加操作次数的前提下调整到是。具体原因只能脑补，不太会严格证明。有了这个结论就可以对l[i],r[i]离散化了。

如果j\in [l[i],r[i]]，i节点可以选择不调整，也可以选择调整至[l[i],r[i]]范围内的其他权值。

如果j\notin [l[i],r[i]]，i节点只能选择调整至[l[i],r[i]]范围内的其他权值。

#include<bits/stdc++.h>
using namespace std ;
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    int T ;
    cin >> T ;
    while(T --)
    {
        int n ;
        cin >> n ;
        vector<vector<int>> g(n + 1) ;
        vector<int> l(n + 1) , r(n + 1) ;
        vector<int> p ;
        for(int i = 1 ; i <= n - 1 ; i ++)
        {
            int u , v ;
            cin >> u >> v ;
            g[u].push_back(v) ;
            g[v].push_back(u) ;
        }
        for(int i = 1 ; i <= n ; i ++)  cin >> l[i] >> r[i] ;
        p.push_back(0) ;
        for(int i = 1 ; i <= n ; i ++)  p.push_back(l[i]) , p.push_back(r[i]) ;
        sort(p.begin() , p.end()) ;
        p.erase(unique(p.begin() , p.end()) , p.end()) ;
        int siz = p.size() ;
        vector<vector<int>> dp(n + 1 , vector<int>(siz , n)) ;
        for(int i = 1 ; i <= n ; i ++)
        {
            l[i] = lower_bound(p.begin() , p.end() , l[i]) - p.begin() ;
            r[i] = lower_bound(p.begin() , p.end() , r[i]) - p.begin() ;
        }
        //dp[i][j]表示节点i的所有祖先的修改的权值和是j的以i为根的子树的最小修改次数
        //j只能是若干个l[i],r[i]及0中的一个，如果不是，可以调整到是。
        function<void(int , int)> dfs = [&](int fa , int u)
        {
            vector<int> sum(siz , 0) ;
            vector<int> pre(siz , n) ;
            vector<int> suf(siz , n) ;
            for(auto v : g[u])
            {
                if(v == fa)  continue ;
                dfs(u , v) ;
                for(int i = 0 ; i < siz ; i ++)  sum[i] += dp[v][i] ;
            }
            for(int i = 0 ; i < siz ; i ++)
            {
                if(i == 0)
                {
                    if(l[u] <= i && i <= r[u])  pre[i] = sum[i] ;
                }
                else
                {
                    if(l[u] <= i && i <= r[u])  pre[i] = min(pre[i - 1] , sum[i]) ;
                    else  pre[i] = pre[i - 1] ;
                }
            }
            for(int i = siz - 1 ; i >= 0 ; i --)
            {
                if(i == siz - 1)
                {
                    if(l[u] <= i && i <= r[u])  suf[i] = sum[i] ;
                }
                else
                {
                    if(l[u] <= i && i <= r[u])  suf[i] = min(suf[i + 1] , sum[i]) ;
                    else  suf[i] = suf[i + 1] ;
                }
            }
            for(int i = 0 ; i < siz ; i ++)
            {
                if(l[u] <= i && i <= r[u])
                {
                    dp[u][i] = min(dp[u][i] , sum[i]) ;
                    int tmp1 = n ;
                    if(i > 0)  tmp1 = pre[i - 1] ;
                    int tmp2 = n ;
                    if(i + 1 < siz)  tmp2 = suf[i + 1] ;
                    dp[u][i] = min({dp[u][i] , tmp1 + 1 , tmp2 + 1}) ;
                }
                else
                {
                    int tmp1 = pre[r[u]] ;
                    int tmp2 = suf[l[u]] ;
                    dp[u][i] = min({dp[u][i] , tmp1 + 1 , tmp2 + 1}) ;
                }
            }
        } ;
        dfs(1 , 1) ;
        int zero = lower_bound(p.begin() , p.end() , 0) - p.begin() ;
        cout << dp[1][zero] << '\n' ;
    }
    return 0 ;
}

 

敲代码的欧文
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2019 Multi-University Training Contest 4(2019hdu多校第六场数据与标程）rar
08-11
《2019 Multi-University Training Contest 4：探索ACM竞赛的魅力与技术深度》 在编程竞赛的世界里，HDU（Hangzhou Dianzi University）举办的Multi-University Training Contest一直备受关注，尤其是2019年的第六...
2020 Multi-University Training Contest 1---- HDU--6762、Mow（半平面交、思维）
_Griefs
08-25 200
题目链接 题面： 题意： 给定一个凸多边形的草坪来割草，有两种方式： 人工割草，单位代价为A，可以随意在任何位置割草 半径为 r 的圆形割草机割草，单位代价为B，要求是割草机不能超过草坪的边界 求割草的最小花费。 题目保证 r 不等于给定凸包的内切圆半径。 题解： 如果人工割草更优，直接人工，面积是多边形面积； 否则的话，很显然只有多边形夹角那里割草机割不到的地方用人工，其他地方都用割草机。 如下图所示，我们将原多边形的每一条边向内部平移 r，构成一个半平面交。 红色：半平面交，也是割草机圆心的移动范围，
2020杭电多校赛 Multi-University Training Contest
打过ICPC/CCPC，学习ACM算法，Linux内核，Openharmony，加油努力开心珍惜
07-17 5425
文章目录2020杭电多校赛 Multi-University Training Contest 2020杭电多校赛 Multi-University Training Contest
2020 杭电多校第五场（Multi-University Training Contest 5）
wait
08-09 263
Tetrahedron 大致题意： 给你一个四面体（三条棱之间分别呈90度），然后给出三条棱 a , b , c 的长度的范围：随机取（1，n）之间的任意一个整数；求四面体的高h：的期望值 思路： 首先要找出来 a, b, c 和之间的关系；(做题的时候随便找的公式)： 官方题解给的证明： #include <bits/stdc++.h> using namespace std; typedef long long ll; const in...
2020 HDU Multi-University Training Contest 2
Nonoka的博客
07-25 257
2020 HDU Multi-University Training Contest 2 文章目录2020 HDU Multi-University Training Contest 21010 Lead of Wisdom题意思路代码1006 The Oculus题意思路代码1001 Total Eclipse题意思路代码1012 String Distance题意思路代码 1010 Lead of Wisdom 链接：HDU6772 Lead of Wisdom 题意 kkk 种物品共 nnn 个 $
2020 Multi-University Training Contest 2---- HDU--6770、Dynamic Convex Hull （离线、分治）
_Griefs
09-01 341
题目连接 题面： 题意： 有一个四次函数的集合 fi(x)=(x−ai)4+bif_i(x)=(x-a_i)^4+b_ifi​(x)=(x−ai​)4+bi​。 有以下三种操作 （1）111 aaa bbb ，往集合中添加新的四次函数 fn+1=(x−a)4+bf_{n+1}=(x-a)^4+bfn+1​=(x−a)4+b，然后n=n+1n=n+1n=n+1 （2）222 ttt ，从集合中删除 ft(x)f_t(x)ft​(x) （3）333 xxx ，在当前集合中询问 fi(x)f_i(x)fi
有2019 Multi-University Training Contest 9，hdu多校第9场的题解.zip
08-19
《2019 Multi-University Training Contest 9 HDU多校第9场题解解析》 在编程竞赛的世界中，ACM（国际大学生程序设计竞赛）是一项备受瞩目的活动，它旨在培养学生的算法设计、问题解决和编程能力。2019年，多所大学...
有2019 Multi-University Training Contest 8数据标程.rar
08-19
有2019 Multi-University Training Contest 8，hdu多校第8场的题解，数据标程，有需要的可以下载哦
2019 Multi-University Training Contest 10数据标程.rar
08-22
标题中的“2019 Multi-University Training Contest 10数据标程.rar”指的是2019年举办的多所大学联合编程训练比赛的第十场竞赛的数据集和参考解程。这个压缩包通常包含了该比赛的所有题目、输入输出样例、评测标准...
2019 Multi-University Training Contest 7数据标程.rar
08-19
《2019 Multi-University Training Contest 7数据标程》是针对 ACM（国际大学生程序设计竞赛）的一份宝贵资源，特别关注了 HDU（杭州电子科技大学）组织的多校第七场比赛。这份压缩包文件包含了该比赛的题解和数据标...
2020 Multi-University Training Contest 2
Consult_
07-27 203
1010 Lead of Wisdom（爆搜优化） Problem Description In an online game, “Lead of Wisdom” is a place where the lucky player can randomly get powerful items. There are k types of items, a player can wear at most one item for each type. For the i-th item, it has fo
2020 Multi-University Training Contest 10
HHeyanjie的博客
08-22 260
A. 题意： 跟节点是1. 第一行输入一个n，代表n个节点，第二行输入n-1个数，代表2~n节点的父亲。 如果节点x能走到节点y，点对数+1，只能走向自己的儿子，不能走向父亲。（即单向边） 你可以增加一条双向边，求增加一条边后可到达的最大点对数。 思路 加边后构成的环肯定可以两两到达，所以肯定是选一个叶子节点连接跟节点，在原有点对数的基础上加上增加的点对数。转化为求哪个叶子节点连跟节点后增加的点对数最多。 步骤 1、dfs记录每个节点的叶子节点 2、dfs2遍历树，记录当前路径增加的对点数==n-该节点儿子
2020 Multi-University Training Contest(杭电多校图论好题)
weixin_46173995的博客
08-07 812
2020杭电多校暑期集训 图论个人总结 Day 4： 补题的时候越发觉得杭电的图论题出的非常好，也是是我做的比较少 这是最近补的两题，比较菜，比赛的时候都没出，补完之后真的觉得题非常好 题目传送门 题意： 有n个节点、m条边构成的无向图，每个节点有特殊的要求，L只能用左手，R只能用右手，M都可以，左右换手需要额外的时间，让你求从s到t花费的最小时间。 比赛的时候觉得这是一道很裸的迪杰斯特拉，但是难点在于当前左右手的状态影响到下一次路径的距离，当时觉得在建图的时候可以把换手的时间算进权值里，但还是不好处
2020 Multi-University Training Contest 5
HKing147的博客
08-07 174
1009-Paperfolding = HDU6822 题目大意 根据从左到右的长度为n的字符串执行一条操作指令，该字符串仅包含L，R，U，D的4个不同字符。 L指令表示将其从左向右折叠， R指令表示从右到左折叠， U指令是指从上到下折叠， D指令表示从下到上对折。 例如，如果从左到右折叠纸张，则应让左侧重叠在右侧，并且不能旋转。 现在，在折叠后的纸张可见部分的中心水平切割（完全切割），然后垂直切割（完全切割）。切割后所得纸张的张数为num(S)。 请参阅示例和图片以更好地理解。 现在给定一个非负整数n，
2019 Multi-University Training Contest 3
ccsu_cat
07-29 673
好吧，还是决定写题解了，今天开局搞05，然后自闭一小时，此时队友签到还没成功…赶紧把06切了，然后放手搞02，和09，双重自闭…队友还没搞定07，赶紧去秒了07，搞着搞着突然想玩一波玄学，09费用流建图只加部分的边，然后就过了…接下来搞04，想明白后就是个二分+线段树优化dp，cf上老套路了，一发切了，最后终于是取得了湖南省内第一，庆祝一下下 1002 Blow up the city 待补 10...
2020 Multi-University Training Contest 5 总结
yzsjwd的博客
08-04 385
2020 Multi-University Training Contest 5 1001：海伦公式加勾股定理，队友直接推好了h的表达式让我求期望。结果我忘记注意范围，同时long long写成11，WA了3发，背锅。 1002：有趣字符串，确实很有趣，跳过。 1003：队友折完1009顺便开始模拟，开始MLE，手写栈模拟过了。 1004：防AK题，跳过。 1005：没想清楚k=1,k=2情况下的具体做法，考虑到花时间想清楚之后也不一定能在时限内求出期望，选择放弃，节约时间。 1006：开场就开的博弈题
2020 Multi-University Training Contest 4 总结
yzsjwd的博客
07-30 407
2020 Multi-University Training Contest 4 1001：防AK题，跳过。 1002：由于双方的血量一样，所以砍死对方花费的时间每个武器是固定的，我们只要挑选花费时间最少的武器即可。 1003：01背包DP，算了算复杂度超时，并没有什么好的算法解决。结果题解是不确定性算法，复杂度超的不多就随机，学到了。 1004：队友秒了，有个好队友就是可以为所欲为。 1005：队友说这不就是斐波那契数列吗，看了看确实是，秒了。 1006：二分角度没敢想，这个二分之后的判断更是精妙，不
2020 Multi-University Training Contest 2 - Total Eclipse
Rrrrya
07-24 205
传送门 题意： 有n个城市，m条道路，每个城市都有一个权值，现在要让每个城市的权值变成0，可执行的操作为：每次选择一个城市，使从这个城市出发能到的所有城市的权值-1，注意：当某个城市的权值变为0之后，它将不能被经过，问最少要几次操作使得所有城市的权值都变成0。 思路： 先把题意抽象出来，也就是每次选择一个连通块，连通块中的点的权值-1，当某个点的权值为0，就不能算在连通块内。由于权值变为0的可能导致不连通的情况，每次选的权值肯定是整个连通块内的最小权值。 我们可以将整个过程倒过来看，从权值最大的点开始
2020 Multi-University Training Contest 8---- HDU--6863、Isomorphic Strings（哈希）
_Griefs
08-28 116
题目链接 题面： 题意： 给定一个长度为 nnn 的串 SSS，问 SSS 能不能划分为 kkk 个等长的串，使得这 kkk 个串循环同构。其中 k>1k>1k>1。 题解： 考虑枚举 kkk，将串 SSS 第一个长度为 nk\frac{n}{k}kn​ 子串的所有循环同构的哈希值保存下来，然后把 SSS 分为 kkk 个长度为 nk\frac{n}{k}kn​ 的串，查询这些哈希值是否存在于 第一个长度为 nk\frac{n}{k}kn​ 循环同构的哈希值里面。 时间复杂度 O(∑
AtCoder Beginner Contest 134 简要题解
最新发布
05-23
AtCoder Beginner Contest 134 是一场 AtCoder 的入门级比赛，以下是每道题的简要题解： A - Dodecagon 题目描述：已知一个正十二边形的边长，求它的面积。 解题思路：正十二边形的内角为 $150^\circ$，因此可以将正十二边形拆分为 12 个等腰三角形，通过三角形面积公式计算面积即可。 B - Golden Apple 题目描述：有 $N$ 个苹果和 $D$ 个盘子，每个盘子最多可以装下 $2D+1$ 个苹果，求最少需要多少个盘子才能装下所有的苹果。 解题思路：每个盘子最多可以装下 $2D+1$ 个苹果，因此可以将苹果平均分配到每个盘子中，可以得到最少需要 $\lceil \frac{N}{2D+1} \rceil$ 个盘子。 C - Exception Handling 题目描述：给定一个长度为 $N$ 的整数序列 $a$，求除了第 $i$ 个数以外的最大值。 解题思路：可以使用两个变量 $m_1$ 和 $m_2$ 分别记录最大值和次大值。遍历整个序列，当当前数不是第 $i$ 个数时，更新最大值和次大值。因此，最后的结果应该是 $m_1$ 或 $m_2$ 中较小的一个。 D - Preparing Boxes 题目描述：有 $N$ 个盒子和 $M$ 个物品，第 $i$ 个盒子可以放入 $a_i$ 个物品，每个物品只能放在一个盒子中。现在需要将所有的物品放入盒子中，每次操作可以将一个盒子内的物品全部取出并分配到其他盒子中，求最少需要多少次操作才能完成任务。 解题思路：首先可以计算出所有盒子中物品的总数 $S$，然后判断是否存在一个盒子的物品数量大于 $\lceil \frac{S}{2} \rceil$，如果存在，则无法完成任务。否则，可以用贪心的思想，每次从物品数量最多的盒子中取出一个物品，放入物品数量最少的盒子中。因为每次操作都会使得物品数量最多的盒子的物品数量减少，而物品数量最少的盒子的物品数量不变或增加，因此这种贪心策略可以保证最少需要的操作次数最小。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值