【2018.11.2】相遇 / 求和 / 小乔

这两天钻我的模拟赛钻得思想僵化了，本来打算弃考，最后半小时才决定手糊一波。

题目

题解

T1

原题……$dp$ / $bfs$ 都行（因为所有边权都是 $1$，第一次扩展到的就是最短路）。

然而我判错了向左走的情况，一下被爆了，降智。

#include<bits/stdc++.h>
using namespace std;
inline int read(){
    int x=0; bool f=1; char c=getchar();
    for(;!isdigit(c);c=getchar()) if(c=='-') f=0;
    for(; isdigit(c);c=getchar()) x=(x<<3)+(x<<1)+(c^'0');
    if(f) return x;
    return 0-x;
}
int a,b,dp[200002];
int main(){
    freopen("meet.in","r",stdin);
    freopen("meet.out","w",stdout);
    a=read(),b=read();
    memset(dp,0x7f,sizeof dp);
    dp[a]=0;
    for(int i=a-1;i>=0;--i) dp[i]=dp[i+1]+1;
    for(int i=0;i<=b;++i){
        dp[i+1]=min(dp[i+1],dp[i]+1);
        if((i<<1)-1<=b) dp[i<<1]=min(dp[i<<1],dp[i]+1), dp[(i<<1)-1]=min(dp[(i<<1)-1],dp[i]+2);
    }
    printf("%d\n",dp[b]);
    return 0;
}

 

T2

我之前做过类似的题，然后现在又忘了-_- 再次降智

题解 $pdf$ 里面貌似写的很清楚了……

必定先考虑全是 $1$ 的情况。打个暴力，然后仔细观察矩阵中每个数是怎么转移来的，发现就是它上面和左面的数相加得到。

那这不就是个斜的杨辉三角么？

如图，最右边一行（橙框部分）是初始序列，然后每操作一次，序列就变为左下一行。

这是初始序列全是 $1$ 的情况，那对于任意初始序列的情况呢？

我们发现，最终序列的每个数，是由初始序列中每个数 乘上很多次得来的。

那系数是多少？

假设杨辉三角从第 $0$ 行第 $0$ 列算起（方便求组合数），则操作 $k$ 次后，第 $i$ 个数 $=$ $C_{k+i-2}^{i-1}\times a_1+C_{k+i-3}^{i-2}\times a_2+C_{k+i-4}^{i-3}\times a_3+...+C_{k-1}^{0}\times a_i$，其中 $a$ 为初始序列。具体举例可以看 $pdf$。

系数反过来对应的原因是杨辉三角每个数的累加量是前缀和，而本题序列每个数的累加量是后缀和（前面的数离后面的数多远，前面的数就被算多少次）。

由于杨辉三角的对称性，反过来推序列也是一样的，每个数的计算公式 改一下上面那个就得到了。

由上述公式可知，第 $k$ 行的每个数被后面的数累加时的系数 只有 $n$ 种，又因为组合数 $C$ 的上面一项最多只有 $n$，所以可以预处理 $n$ 以内的逆元，再 $O(n^2)$ 暴力求出 $n$ 种系数（每个组合数最多是乘 $n$ 个数再除以 $n$ 个数，暴力计算的复杂度是 $O(n)$），最后用上述公式，把每个数前面的数都乘以对应的系数，累加即可求出这个数。时间复杂度 $O(n^2)$。

#include<bits/stdc++.h>
#define int long long
using namespace std;
inline int read()
{
    int x = 0,f = 1;char ch = getchar();
    for(;!isdigit(ch);ch = getchar())if(ch == '-')f = -f;
    for(;isdigit(ch);ch = getchar())x = 10 * x + ch - '0';
    return x * f;
}
const int maxn = 5010,mod = 1e9 + 7;
int n,k;int a[maxn],s[maxn],Inv[maxn];
inline int ksm(int x,int t)
{
    int res = 1;
    while(t)
    {
        if(t & 1)res = res * x % mod;
        x = x * x % mod;
        t = t >> 1;
    }
    return res;
}
inline int inv(int x){return ksm(x,mod - 2);}
/*sig (1~x) from (x + k - i) choose (i) * a[0][i]*/
inline int C(int n,int m)
{
    if(n < m || n < 0 || m < 0)return 0;
    int cur = n,ans = 1;
    for(int i=m;i>=1;i--)
    {
        (ans *= cur) %= mod;
        (ans *= Inv[i]) %= mod;
        cur--;
    }
    return ans;
}
int xs[maxn];
signed main()
{
    freopen("sum.in","r",stdin);
    freopen("sum.out","w",stdout);
    n = read();k = read() - 1;
    //for(int i=1;i<=n+k;i++)fac[i] = fac[i - 1] * i % mod;
    Inv[0] = 1;
    for(int i=1;i<=n;i++)Inv[i] = inv(i);
    for(int i=1;i<=n;i++)a[i] = read();
    //for(int i=1;i<=n;i++)a[i] -= a[i - 1];
    //for(int i=1;i<=n;i++)cout<<a[i]<<" "; 
    for(int i=1;i<=n;i++)xs[i] = C(i + k - 1,(i + k - 1) - k) % mod;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=i;j++)
            (s[i] += xs[i - j + 1] * a[j]) %= mod;
    for(int i=1;i<=n;i++)printf("%lld ",s[i]);
}

 

T3

没好好想，瞎搞了一个时间复杂度不对的线段树就交上去了。

#include<bits/stdc++.h>
#define ll long long
#define N 100002
#define M 200002
#define inf 1000000000
using namespace std;
inline int read(){
    int x=0; bool f=1; char c=getchar();
    for(;!isdigit(c);c=getchar()) if(c=='-') f=0;
    for(; isdigit(c);c=getchar()) x=(x<<3)+(x<<1)+(c^'0');
    if(f) return x;
    return 0-x;
}
int n,m,k;
ll ans;
struct input{
    int r,s,t;
    inline bool operator <(const input x)const{
        return r>x.r;
    }
}in[N];
int L,R;
namespace SegmentTree{
    struct Tree{
        int tag,mx,mn;
    }tr[M<<3];
    ll num[M];
    inline void pushdown(int o){
        if(tr[o].tag)
            tr[o<<1].mx+=tr[o].tag, tr[o<<1].mn+=tr[o].tag,
            tr[o<<1|1].mx+=tr[o].tag, tr[o<<1|1].mn+=tr[o].tag,
            tr[o<<1].tag+=tr[o].tag, tr[o<<1|1].tag+=tr[o].tag, tr[o].tag=0;
    }
    inline void pushup(int o){tr[o].mx=max(tr[o<<1].mx,tr[o<<1|1].mx), tr[o].mn=min(tr[o<<1].mn,tr[o<<1|1].mn);}    
    void update(int o,int l,int r){
        //printf("udpate %d %d %d %d\n",L,l,r,R);
        if(L<=l && r<=R){
            ++tr[o].tag, ++tr[o].mx, ++tr[o].mn;
            return;
        }
        pushdown(o);
        int mid=(l+r)>>1;
        if(L<=mid) update(o<<1,l,mid);
        if(R>mid) update(o<<1|1,mid+1,r);
        pushup(o);
    }
    ll query(int o,int l,int r){
        if(tr[o].mx==tr[o].mn){
            //printf("success %d %d\n",l,r);
            tr[o].mx=tr[o].mn=-inf, tr[o].tag=0;
            return r-l+1;
        }
        //printf("tag:%d\n",tr[o].tag);
        pushdown(o);
        //printf("revo %d %d %d %d %d %d\n",l,r,tr[o].mx,tr[o<<1].mx,tr[o<<1|1].mx,tr[o].mn);
        int mid=(l+r)>>1; ll ret=0;
        if(tr[o<<1].mx==tr[o].mx) ret+=query(o<<1,l,mid);
        if(tr[o<<1|1].mx==tr[o].mx) ret+=query(o<<1|1,mid+1,r);
        pushup(o);
        return ret;
    }
};
using namespace SegmentTree;
inline void action(int i,int l,int r){
    //printf("action:%d %d %d\n",i,l,r);
    L=l,R=r;
    update(1,1,m);
    if(tr[1].mx==k) ans+=query(1,1,m)*in[i].r*in[i].r;
//    printf("%lld\n",ans);
}
int main(){
    freopen("xiaoqiao.in","r",stdin);
    freopen("xiaoqiao.out","w",stdout); 
    n=read(),m=read(),k=read();
    int i;
    for(i=1;i<=n;++i) in[i].r=read(), in[i].s=read()+m+1, in[i].t=read()+m;
    sort(in+1,in+n+1);
    m<<=1;
    for(i=1;i<=n;++i){
        if(in[i].s>in[i].t) action(i,in[i].s,m), action(i,1,in[i].t);
        else action(i,in[i].s,in[i].t);
    }
    printf("%lld\n",ans);
    return 0;
}

容易发现 $query$ 的复杂度错了，不是 $log$ 级别的，然后就就被爆踩。

由于只需要求最终的全局情况，也就是说答案跟操作顺序没关系，我们可以搞离线。

于是想到扫描线。

扫描线是个啥东西？如图

可以把问题同义转化一下：在墙上贴 $n$ 张底线相同、高度不同的海报，问有多大面积的区域至少被 $k$ 张海报覆盖。

然后我们在左端点搞一条扫描线（黑线）。

 

把扫描线不停往右移动，扫到下一个海报的左端点时，更新一下当前纵轴上的覆盖海报数（不能只 $+1$，因为可能有多个海报的左端点重合）。如果海报数 $\ge k$，就二分出从下往上数第 $k$ 个海报端点的位置，它下面就是覆盖海报数 $\ge k$ 的区域。

当扫描线扫到下一个位置时，累加它到上一个扫到的位置围出的 覆盖海报数 $\ge k$ 的区域面积，并再做上述更新即可。

所以我们把每张海报拆成左右两个端点，现在问题就变成了维护一个数据结构，支持单点插入、单点删除、查询第 $k$ 大值。

复杂度基本是对的，因为最多有 $2m$ 张海报，也就是 $4m=400000$ 个端点，那总共就有 $400000$ 次插入、删除操作（两个加起来）。

查询第 $k$ 大值就看卡常优不优秀了。这是个比较板子的维护，一种方法是树状数组二分（弱智写法的总时间复杂度是 $O(n*log(n^2))$，优秀写法的总时间复杂度是 $O(n*log(n))$），一种方法是平衡树（韩神现场yy了一个没写过的 $SBT$ 就 $A$ 了；总时间复杂度 $O(n*log(n))$ 带常数），还有一种方法是权值线段树（树上自带二分，总时间复杂度 $O(n*log(high))$）。

由于树状数组的常数小，所以跑的甚至比平衡树快一点……

#include<bits/stdc++.h>
#define LL long long
using namespace std;
inline int read()
{
    int x = 0,f = 1;char ch = getchar();
    for(;!isdigit(ch);ch = getchar())if(ch == '-')f = -f;
    for(;isdigit(ch);ch = getchar())x = 10 * x + ch - '0';
    return x * f;
}
const int maxn = 400005;
int n,m,kk;
int top1,top2;
struct qwq{int l,r,R;}nega[maxn],posi[maxn];
struct ques{int st,r;char f;bool operator < (const ques &b)const{return st<b.st;}}opts[maxn];

namespace RP
{
    struct node{int ls,rs,size,val;}tr[maxn << 2];
    int dfn,root,ops;
    inline void pushup(int x){tr[x].size=tr[tr[x].ls].size+tr[tr[x].rs].size+1;}
    inline void lt(int &x)
    {
        int k=tr[x].rs;tr[x].rs=tr[k].ls;
        tr[k].ls=x;tr[k].size=tr[x].size;
        pushup(x);
        x=k;
    }
    inline void rt(int &x)
    {
        int k=tr[x].ls;tr[x].ls=tr[k].rs;
        tr[k].rs=x;tr[k].size=tr[x].size;
        pushup(x);
        x=k;
    }
    inline int rng()
    {
        static unsigned long long seed = 233333333333333333LL;
        seed = seed + (seed << 17) + 531433123515;
        return seed;
    }
    /*
    void rp()
    {
        int x;
        for(int i=1;i<=min(n,10);i++)lt(x = rng() % n + 1);
        for(int i=1;i<=min(n,10);i++)rt(x = rng() % n + 1);
    }
    */
    inline void magic(int &x,char f)
    {
        if(f)
        {
            if(tr[tr[tr[x].ls].ls].size > tr[tr[x].rs].size) rt(x),rt(x);
            else if(tr[tr[tr[x].ls].rs].size > tr[tr[x].rs].size) lt(tr[x].ls),rt(x);
            else return;
        }
        else
        {
            if (tr[tr[tr[x].rs].rs].size > tr[tr[x].ls].size) lt(x);
            else if (tr[tr[tr[x].rs].ls].size > tr[tr[x].ls].size) rt(tr[x].rs),lt(x);
            else return;
        }
        if(rng() & 1)lt(x); //Lucky!
        magic(tr[x].ls,0);magic(tr[x].rs,1);
        return;
    }
    inline void Insert(int &x,int v)
    {
        if (!x)
        {
            x = ++dfn;
            tr[x].ls = tr[x].rs = 0;
            tr[x].size = 1;
            tr[x].val = v;
            //rp();
        }
        else
        {
            tr[x].size++;
            if (v<tr[x].val) Insert(tr[x].ls,v);
            else Insert(tr[x].rs,v);
            magic(x,v < tr[x].val);
        }
    }
    inline int del(int &x,int v)
    {
        tr[x].size--;
        int k = tr[x].val;
        if (v == k || (v < k && !tr[x].ls) || (v > k && !tr[x].rs) )
        {
            if (!tr[x].ls || !tr[x].rs) x = tr[x].ls + tr[x].rs;
            else tr[x].val = del(tr[x].ls,v + 1);
            return k;
        }
        else
        {
            if (v < k) return del(tr[x].ls,v);
            else return del(tr[x].rs,v);
        }
    }
    inline int kth(int k)
    {
        int x = root;
        while(tr[tr[x].ls].size + 1 != k)
        {
            if(tr[tr[x].ls].size+1 < k) k -= tr[tr[x].ls].size,k--,x = tr[x].rs;
            else x = tr[x].ls;
        }
        return tr[x].val;
    }
}
using namespace RP;
int main()
{
    freopen("xiaoqiao.in","r",stdin);
    freopen("xiaoqiao.out","w",stdout);
    n = read(),m = read(),kk = read();
    for(int i=1;i<=n;i++)
    {
        int R = read(),l = read(),r = read();
        if(l == m) l = -m;
        if(r == -m) r = m;
        if(l == r) continue;
        if(l >= 0 && r >= 0)
        {
            if(l > r)
            {
                if(m) nega[++top1]=(qwq){-m,0,R};
                if(l != m) posi[++top2]=(qwq){l,m,R};
                
                if(r) posi[++top2]=(qwq){0,r,R};
            }
            else posi[++top2]=(qwq){l,r,R};
        }
        else if(l <= 0 && r <= 0)
        {
            if(l > r)
            {
                if(l) nega[++top1]=(qwq){l,0,R};
                if(r != -m) nega[++top1]=(qwq){-m,r,R};
                
                if(m) posi[++top2]=(qwq){0,m,R};
            }
            else nega[++top1]=(qwq){l,r,R};
        }
        else if (l <= 0 && r >= 0)
        {
            if (l) nega[++top1]=(qwq){l,0,R};
            if (r) posi[++top2]=(qwq){0,r,R};
        }
        else if(l >= 0 && r <= 0)
        {
            nega[++top1]=(qwq){-m,r,R};
            posi[++top2]=(qwq){l,m,R};
        }
    }
    LL res1 = 0,res2 = 0;
    
    root = dfn = ops = 0;
    for(int i=1;i<=top1;i++)
    {
        opts[++ops] = (ques){nega[i].l,nega[i].R,1};
        opts[++ops] = (ques){nega[i].r,nega[i].R,0};
    }
    sort(opts + 1,opts + ops + 1);
    int last = opts[1].st;
    int l = 1,r = 1;
    while(l <= ops)
    {
        while(r <= ops && opts[r].st == opts[l].st) r++;
        if(tr[root].size >= kk)
        {
            LL x = kth(tr[root].size - kk + 1); //di k da = n - k + 1 xiao
            res1 += x * x * (opts[l].st - last);
        }
        for(int i=l;i<r;i++)
        {
            if(opts[i].f == 1) Insert(root,opts[i].r);
            else del(root,opts[i].r);
        }
        last = opts[l].st;
        l = r;
    }
    
    root = dfn = ops = 0;
    for(int i=1;i<=top2;i++)
    {
        opts[++ops] = (ques){posi[i].l,posi[i].R,1};
        opts[++ops] = (ques){posi[i].r,posi[i].R,0};
    }
    sort(opts + 1,opts + ops + 1);
    last = opts[1].st;
    l = 1,r = 1;
    while(l <= ops)
    {
        while(r <= ops && opts[r].st == opts[l].st) r++;
        if(tr[root].size >= kk)
        {
            LL x = kth(tr[root].size - kk + 1); //di k da = n - k + 1 xiao
            res2 += x * x * (opts[l].st - last);
        }
        for(int i=l;i<r;i++)
        {
            if(opts[i].f == 1) Insert(root,opts[i].r);
            else del(root,opts[i].r);
        }
        last = opts[l].st;
        l = r;
    }
    cout<<res1 + res2;
}

#include<bits/stdc++.h>
#define rep(i,x,y) for(int i=(x);i<=(y);++i)
#define dwn(i,x,y) for(int i=(x);i>=(y);--i)
#define LL long long
#define maxn 200010
using namespace std;
int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)&&ch!='-')ch=getchar();
    if(ch=='-')ch=getchar(),f=-1;
    while(isdigit(ch))x=(x<<1)+(x<<3)+ch-'0',ch=getchar();
    return x*f;
}
void write(LL x)
{
    if(x==0){putchar('0'),putchar('\n');return;}
    if(x<0)putchar('-'),x=-x;
    int f=0;char ch[20];
    while(x)ch[++f]=x%10+'0',x/=10;
    while(f)putchar(ch[f--]);
    putchar('\n');
    return;
}
int n,m,k,qr,qs,qt,tr[maxn];
int tpr;
LL ans;
int lt(int x){return x&(-x);}
void add(int x,int k){for(;x<=tpr;x+=lt(x))tr[x]+=k;return;}
int ask(int x){int k=0;for(;x;x-=lt(x))k+=tr[x];return k;}
vector<int>ad[maxn],de[maxn];
int gx(int x){return m-x;}
int nxt(int x){if(x>(m<<1))return x-(m<<1);if(x<1)return (m<<1)-x;return x;}
int main()
{
    freopen("xiaoqiao.in","r",stdin);
    freopen("xiaoqiao.out","w",stdout);
    n=read(),m=read(),k=read();
    rep(i,1,n)
    {
        qr=read(),qs=read(),qt=read();
        qs=gx(qs),qt=gx(qt),qt=nxt(qt+1),qs=nxt(qs),swap(qs,qt);
        if(qs<=qt)
        {
            ad[qs].push_back(qr),de[qt+1].push_back(qr);
        }
        else 
        {
            ad[1].push_back(qr),de[qt+1].push_back(qr);
            ad[qs].push_back(qr),de[m*2+1].push_back(qr);
        }
        tpr=max(tpr,qr);
    }tpr++;int li=m*2;
    rep(i,1,li)
    {
        int lim=ad[i].size()-1;
        rep(j,0,lim)add(1,1),add(ad[i][j]+1,-1);
        lim=de[i].size()-1;
        rep(j,0,lim)add(1,-1),add(de[i][j]+1,1);
        int L=1,R=tpr,maxl=0;
        while(L<=R)
        {
            int mid=(L+R>>1);
            int tmp=ask(mid);
            if(tmp>=k)maxl=max(maxl,mid),L=mid+1;
            else R=mid-1;
        }
        ans+=(LL)maxl*(LL)maxl;
    }
    write(ans);
    return 0;
}