[家里训练20_02_28]ABC

A：有字符串A和B，若A和B匹配，那么字符集存在一个单射，使得F(A)=B。现在给出长度为n的序列和长度为m的序列，问第一个序列中有多少子串与第二个序列匹配。

回想kmp的过程，事实上，只要“等于号”满足传递性就可以进行匹配。

看代码就知道了。

#include<bits/stdc++.h>
using namespace std;
const int maxn=1E6+5;
int n,m,a[maxn],b[maxn],f[maxn],last[maxn],lastA[maxn],bucket[maxn],ans[maxn];
inline int read()
{
    char ch=getchar();
    while(!isdigit(ch))ch=getchar();
    int sum=ch-'0';ch=getchar();
    while(isdigit(ch)){sum=sum*10+ch-'0';ch=getchar();}
    return sum;
}
int G[55];
inline void write(int x,const char&ch)
{
    int g=0;
    do{G[++g]=x%10;x/=10;}while(x);
    for(int i=g;i>=1;--i)putchar('0'+G[i]);putchar(ch);
}
inline bool match(int x,int y)
{
    if(last[y]>=x||last[y]==0)
    {
        if(last[x]==0)
            return true;
        return false;
    }
    else
    {
        if(b[x-last[y]]==b[x])
            return true;
        return false;
    }
}
inline bool matchA(int x,int y)
{
    if(lastA[y]>=x||lastA[y]==0)
    {
        if(last[x]==0)
            return true;
        return false;
    }
    else
    {
        if(b[x-lastA[y]]==b[x])
            return true;
        return false;
    }
}
inline void solve()
{
    memset(f,0,sizeof(f));
    memset(last,0,sizeof(last));
    memset(lastA,0,sizeof(lastA));
    memset(bucket,0,sizeof(bucket));
    n=read(),m=read();
    for(int i=1;i<=n;++i)
    {
        a[i]=read();
        lastA[i]=bucket[a[i]];
        bucket[a[i]]=i;
    }
    memset(bucket,0,sizeof(bucket));
    for(int i=1;i<=m;++i)
    {
        b[i]=read();
        last[i]=bucket[b[i]];
        bucket[b[i]]=i;
    }
    for(int i=1;i<=m;++i)
        if(last[i])
            last[i]=i-last[i];
    for(int i=1;i<=n;++i)
        if(lastA[i])
            lastA[i]=i-lastA[i];
    int pos=0;
    for(int i=2;i<=m;++i)
    {
        while(pos&&!match(pos+1,i))
            pos=f[pos];
        if(match(pos+1,i))
            ++pos;
        f[i]=pos;
    }
    int tot=0;
    pos=0;
    for(int i=1;i<=n;++i)
    {
        while(pos&&!matchA(pos+1,i))
            pos=f[pos];
        if(matchA(pos+1,i))
            ++pos;
        if(pos==m)
        {
            ans[++tot]=i-m+1;
            pos=f[pos];
        }
    }
    write(tot,'
');
    for(int i=1;i<=tot;++i)
        write(ans[i],' ');
    putchar('
');
}
int main()
{
//    freopen("xiz.in","r",stdin);
//    freopen("xiz.out","w",stdout);
    ios::sync_with_stdio(false);
    int T=read(),useless=read();
    while(T--)
        solve();
    return 0;
}

---

B：n个同心圆，每个同心圆上选择一个点，问这些点组成的凸包面积最大为多少。n<=8。

一个三角形面积计算可以看成是a*b*sin/2，这里不用叉积，方便拉格朗日数乘，没什么好说的。

可以看csl的。

#include<bits/stdc++.h>
using namespace std;
typedef long double ld;
const ld pi=acos(-1);
const ld eps=1E-8;
int n,m,p[55];
ld ans,a[55],r[55],theta[55];
inline bool cmp(ld x,ld y)
{
    return x>y;
}
inline ld get(ld lambda)
{
    ld tot=0,sum=0;
    r[m+1]=r[1];
    for(int i=1;i<=m;++i)
    {
        theta[i]=acos(lambda/(r[i]*r[i+1]));
        tot+=theta[i];
    }
    return tot;
}
inline void solve()
{
    for(int i=1;i<=m;++i)
        r[i]=a[p[i]];
    ld L=-a[n]*a[n-1],R=a[n]*a[n-1],mid;
    while(abs(L-R)>eps)
    {
        mid=(L+R)/2;
        if(get(mid)>=2*pi)
            L=mid;
        else
            R=mid;
    }
    if(abs(get(mid)-2*pi)<=0.000001)
    {
        r[m+1]=r[1];
        ld sum=0;
        for(int i=1;i<=m;++i)
            sum+=r[i]*r[i+1]*sin(theta[i]);
        ans=max(ans,sum);
    }
}
int main()
{
//    freopen("yja.in","r",stdin);
//    freopen("yja.out","w",stdout);
    ios::sync_with_stdio(false);
    cin>>n;
    for(int i=1;i<=n;++i)
        cin>>a[i];
    sort(a+1,a+n+1,cmp);
    for(m=3;m<=n;++m)
    {
        for(int i=1;i<=m;++i)
            p[i]=i;
        do
        {
            solve();
        }while(next_permutation(p+1,p+m+1));
    }
    cout<<fixed<<setprecision(8)<<ans/2<<endl;
    return 0;
}
/*
276500.1521568
8
100 200 300 400 500 600 700 1000
8
1 100 300 400 500 600 700 1000
8
1 1 1 1 1000 1000 1000 1000
*/

---

C：区间排序（有升序，也有降序），区间求和。

这是std的代码，不知为何有这么长。

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cctype>
#include <climits>
#include <cassert>
#include <ctime>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <functional>
#include <string>

#define x first
#define y second
#define MP std::make_pair
#define VAL(x) #x " = " << x << " "
#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
#ifdef __linux__
#define getchar getchar_unlocked
#define putchar putchar_unlocked
#endif

typedef long long LL;
typedef std::pair<int, int> Pii;

const int oo = 0x3f3f3f3f;

template<typename T> inline bool chkmax(T &a, T b) { return a < b ? a = b, true : false; }
template<typename T> inline bool chkmin(T &a, T b) { return a > b ? a = b, true : false; }
std::string procStatus()
{
    std::ifstream t("/proc/self/status");
    return std::string(std::istreambuf_iterator<char>(t), std::istreambuf_iterator<char>());
}
template<typename T> T read(T &x)
{
    int f = 1;
    char ch = getchar();
    for (; !isdigit(ch); ch = getchar())
        if (ch == '-')
            f = -1;
    for (x = 0; isdigit(ch); ch = getchar())
        x = 10 * x + ch - '0';
    return x *= f;
}
template<typename T> void write(T x)
{
    if (x == 0) {
        putchar('0');
        return;
    }
    if (x < 0) {
        putchar('-');
        x = -x;
    }
    static char s[20];
    int top = 0;
    for (; x; x /= 10)
        s[++top] = x % 10 + '0';
    while (top)
        putchar(s[top--]);
}


typedef long double LD;

const int MAXN = 2e5 + 5, MAXM = 2e5 + 5;

int N, M;
int A0[MAXN];
LD A[MAXN];
int id[MAXN], begin[MAXN], end[MAXN];
bool incp[MAXN];
std::pair<LD, int> hash[MAXN];

namespace GlobalSEGT
{

const int SIZE = MAXN << 2;

int min[SIZE], max[SIZE];
LD sum[SIZE];
int modt[SIZE];
bool modp[SIZE];
bool cleart[SIZE];
int L, R;
int Xmin, Xmax;
LD Xsum;

#define LC (u << 1)
#define RC (u << 1 | 1)

inline void tagClear(int u)
{
    cleart[u] = true;
    sum[u] = 0;
}

inline void tagMod(int u, int x)
{
    modp[u] = true;
    min[u] = max[u] = modt[u] = x;
}

inline void pushdown(int u)
{
    if (cleart[u]) {
        tagClear(LC);
        tagClear(RC);
        cleart[u] = false;
    }
    if (modp[u]) {
        tagMod(LC, modt[u]);
        tagMod(RC, modt[u]);
        modp[u] = false;
    }
}

inline void pushup(int u)
{
    min[u] = std::min(min[LC], min[RC]);
    max[u] = std::max(max[LC], max[RC]);
    sum[u] = sum[LC] + sum[RC];
}

void _update(int u, int l = 1, int r = N)
{
    if (l == r) {
        sum[u] = Xsum;
        return;
    }
    pushdown(u);
    int mid = (l + r) >> 1;
    if (L <= mid)
        _update(LC, l, mid);
    else
        _update(RC, mid + 1, r);
    pushup(u);
}

void _modify(int u, int l = 1, int r = N)
{
    if (L <= l && r <= R) {
        tagMod(u, Xmin);
        return;
    }
    pushdown(u);
    int mid = (l + r) >> 1;
    if (L <= mid)
        _modify(LC, l, mid);
    if (mid < R)
        _modify(RC, mid + 1, r);
    pushup(u);
}

void _clear(int u, int l = 1, int r = N)
{
    if (L <= l && r <= R) {
        tagClear(u);
        return;
    }
    pushdown(u);
    int mid = (l + r) >> 1;
    if (L <= mid)
        _clear(LC, l, mid);
    if (mid < R)
        _clear(RC, mid + 1, r);
    pushup(u);
}

void _query(int u, int l = 1, int r = N)
{
    if (L <= l && r <= R) {
        chkmin(Xmin, min[u]);
        chkmax(Xmax, max[u]);
        Xsum += sum[u];
        return;
    }
    pushdown(u);
    int mid = (l + r) >> 1;
    if (L <= mid)
        _query(LC, l, mid);
    if (mid < R)
        _query(RC, mid + 1, r);
}

inline void update(int p, LD sm)
{
    L = p;
    Xsum = sm;
    _update(1);
}

inline void modify(int l, int r, int x)
{
    L = l; R = r;
    Xmin = x;
    _modify(1);
}

inline void clear(int l, int r)
{
    L = l; R = r;
    _clear(1);
}

inline void query(int l, int r, int &mn, int &mx, LD &sm)
{
    L = l; R = r;
    Xmin = +oo; Xmax = -oo; Xsum = 0;
    _query(1);
    mn = Xmin; mx = Xmax; sm = Xsum;
}

}

namespace SEGT
{

const int SIZE = 1e7 + 5;

int size, lc[SIZE], rc[SIZE];
int cnt[SIZE];
LD sum[SIZE];

inline void pushup(int u)
{
    cnt[u] = cnt[lc[u]] + cnt[rc[u]];
    sum[u] = sum[lc[u]] + sum[rc[u]];
}

void insert(int &u, int p, int l = 1, int r = N)
{
    if (u == 0)
        u = ++size;
    if (l == r) {
        ++cnt[u];
        sum[u] += hash[l].x;
        return;
    }
    int mid = (l + r) >> 1;
    if (p <= mid)
        insert(lc[u], p, l, mid);
    else
        insert(rc[u], p, mid + 1, r);
    pushup(u);
}

LD query(int u, int lim, int l = 1, int r = N)
{
    if (u == 0 || lim <= 0)
        return 0;
    if (cnt[u] <= lim)
        return sum[u];
    int mid = (l + r) >> 1;
    return query(lc[u], lim, l, mid) + query(rc[u], lim - cnt[lc[u]], mid + 1, r);
}

void merge(int &u, int v, int l = 1, int r = N)
{
    if (v == 0)
        return;
    if (u == 0) {
        u = v;
        return;
    }
    int mid = (l + r) >> 1;
    merge(lc[u], lc[v], l, mid);
    merge(rc[u], rc[v], mid + 1, r);
    pushup(u);
}

void split(int &u, int &v, int kth, int l = 1, int r = N)
{
    if (v == 0)
        v = ++size;
    lc[v] = rc[v] = 0;
    int mid = (l + r) >> 1;
    if (cnt[lc[u]] >= kth) {
        rc[v] = rc[u];
        rc[u] = 0;
        if (cnt[lc[u]] > kth)
            split(lc[u], lc[v], kth, l, mid);
    } else
        split(rc[u], rc[v], kth - cnt[lc[u]], mid + 1, r);
    pushup(u);
    pushup(v);
}

}

void input()
{
    read(N); read(M);
    for (int i = 1; i <= N; ++i) {
        read(A0[i]);
    }
}

void solve()
{
    LD bound[15];

    for (int i = 1; i < 10; ++i) {
        bound[i] = log10((LD)i);
    }

    for (int i = 1; i <= N; ++i) {
        A[i] = log10((LD)A0[i]);
        hash[i] = MP(A[i], i);
    }
    std::sort(hash + 1, hash + N + 1);
    for (int i = 1; i <= N; ++i) {
        id[hash[i].y] = i;
    }

    static int root[MAXN];

    for (int i = 1; i <= N; ++i) {
        root[i] = ++SEGT::size;
        SEGT::insert(root[i], id[i]);
        begin[i] = end[i] = i;
        GlobalSEGT::modify(i, i, i);
        GlobalSEGT::update(i, A[i]);
        incp[i] = true;
    }

    while (M--) {
        int type;
        int l, r;
        read(type); read(l); read(r);

        if (type == 1) {
            int flag;
            read(flag);

            int lp, rp;
            LD sum;
            GlobalSEGT::query(l, r, lp, rp, sum);
            if (begin[lp] < l) {
                int s = begin[lp];
                if (incp[s])
                    SEGT::split(root[s], root[l], l - s);
                else {
                    SEGT::split(root[s], root[l], lp + 1 - l);
                    std::swap(root[s], root[l]);
                }
                begin[lp] = l;
                incp[l] = incp[s];
                begin[l - 1] = s;
                end[s] = l - 1;
                GlobalSEGT::modify(s, l - 1, l - 1);
                GlobalSEGT::clear(s, l - 1);
                GlobalSEGT::update(s, SEGT::sum[root[s]]);
            }
            if (rp > r) {
                int t = begin[rp];
                if (incp[t])
                    SEGT::split(root[t], root[r + 1], r + 1 - t);
                else {
                    SEGT::split(root[t], root[r + 1], rp - r);
                    std::swap(root[t], root[r + 1]);
                }
                begin[rp] = r + 1;
                end[r + 1] = rp;
                incp[r + 1] = incp[t];
                GlobalSEGT::modify(r + 1, rp, rp);
                GlobalSEGT::clear(r + 1, rp);
                GlobalSEGT::update(r + 1, SEGT::sum[root[r + 1]]);
            }
            for (int j = lp + 1; j <= r; j = end[j] + 1) {
                SEGT::merge(root[l], root[j]);
            }

            begin[r] = l;
            end[l] = r;
            incp[l] = flag;
            GlobalSEGT::modify(l, r, r);
            GlobalSEGT::clear(l, r);
            GlobalSEGT::update(l, SEGT::sum[root[l]]);
        } else {
            int lp, rp;
            LD x;
            GlobalSEGT::query(l, r, lp, rp, x);
            if (begin[lp] < l) {
                int s = begin[lp];
                x += incp[s] ? SEGT::sum[root[s]] - SEGT::query(root[s], l - s) : SEGT::query(root[s], lp + 1 - l);
            }
            if (rp > r) {
                int t = begin[rp];
                x -= incp[t] ? SEGT::sum[root[t]] - SEGT::query(root[t], r + 1 - t) : SEGT::query(root[t], rp - r);
            }

            x -= floor(x);
            int ans = std::upper_bound(bound + 1, bound + 10, x) - bound - 1;
            write(ans); putchar('
');
        }
    }
}

int main()
{
//    freopen("zkb.in", "r", stdin);
  //  freopen("zkb.out", "w", stdout);

    input();
    solve();

    return 0;
}