51Nod 试题泛做1

A-排船的问题

很显然，这个数据范围用二分来找这个最长的最短是OK的，
然后我们就判断一下二分到的东西，用一个贪心，就是尽可能将每一个往左边放，但不能与船重叠，也不能超过我们二分到的最长的绳的长度，因为要尽可能给后面留出空间，让后面的绳的长度不超过我们二分到的长度。
然后如果最后极限的方法仍飞出了港口，那自然就是不行的，就继续二分。

可以这样理解。

点击查看代码

#include<bits/stdc++.h>
using namespace std;
const int MAXN=5e4+5;
 
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch))
    {
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(isdigit(ch))
    {
        x=(x<<1)+(x<<3)+(ch^48);
        ch=getchar();
    }
    return x*f;
}
 
int n,x,m;
int p[MAXN];
 
inline bool check(int pos)
{
    int head=0,tail=0;
    for(int i=1;i<=n;i++)
    {
        head=tail;
        if(head+x>p[i]+pos) return false;
        tail=max(head+2*x,p[i]-pos+x);
    }
    if(tail>m) return false;
    return true;
}
 
int main()
{
    n=read(),x=read(),m=read();
    for(int i=1;i<=n;i++) p[i]=read();
    if((x*2*n)>m) {printf("-1\n");return 0;}
    int l=0,r=m-1,ans;
    while(l<=r)
    {
        int mid=(l+r)>>1;
        if(check(mid))ans=mid,r=mid-1;
        else l=mid+1;
    }
    printf("%d\n",ans);
    return 0;
}

B-稳定桌

首先，我们看复杂度，题目数据范围是 $1\leqslant n \leqslant 10^5$，那么一种 $\mathcal{O}(n\log n)$ 会是比较可能的。

然后分析题目可以想到一个方法：从小到大枚举我们要留下的最长桌腿的长度 $i$，将长度大于 $i$ 的桌腿全删掉，此时考虑一下是否删够了，即我们枚举到的 $i$ 的数量是否超过了剩下数量的一半，超过就直接更新答案好了，没满足就还得从比 $i$ 小的里面删。

然后就来到了本题的关键部分：
该如何筛选比 $i$ 小的桌腿呢？

显然，若假设还需删 $k$ 条，那么肯定是在小的里面找消耗能量前 $k$ 小的删掉。教练第一反应是平衡树，但太难写也太难调，所以我们这里考虑到用权值线段树。

取所有代价中的最大值 $maxd$，以 $1\sim maxd$ 为值域建立权值线段树，在此过程中我们要记录两个量，$sum_i$ 是子树中所有代价之和，$num_i$ 是子树中桌腿的数量。

然后我们要保证有序，就在枚举的同时，将每一次枚举完的桌腿都插到树里，将小的往左插，大的往右插。

点击查看代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int MAXN=1e5+5;
const int INF=0x7f7f7f7f7f7f7f7f;
 
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch))
    {
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(isdigit(ch))
    {
        x=(x<<1)+(x<<3)+(ch^48);
        ch=getchar();
    }
    return x*f;
}
 
int n;
vector<int>V[MAXN];
int t[MAXN<<2],num[MAXN<<2];
 
inline void pushup(int p)
{
    t[p]=t[p<<1]+t[p<<1|1];
    num[p]=num[p<<1]+num[p<<1|1];
    return;
}
 
inline void change(int p,int l,int r,int k)
{
    if(l==r)
    {
        num[p]++,t[p]+=k;
        return;
    }
    int mid=(l+r)>>1;
    if(k<=mid) change(p<<1,l,mid,k);
    else change(p<<1|1,mid+1,r,k);
    pushup(p);
}
 
inline int ask(int p,int l,int r,int k)
{
    if(l==r) return l*k;
    int mid=(l+r)>>1;
    if(num[p<<1]==k) return t[p<<1];
    else if(num[p<<1]>k) return ask(p<<1,l,mid,k);
    else return t[p<<1]+ask(p<<1|1,mid+1,r,k-num[p<<1]);
}
 
int l[MAXN],d[MAXN];
 
signed main()
{
    n=read();int maxl=-1,maxd=-1;int ans=INF,sum=0,cnt=0,add;
    for(int i=1;i<=n;i++) l[i]=read(),maxl=max(maxl,l[i]);
    for(int i=1;i<=n;i++)
    {
        d[i]=read();maxd=max(maxd,d[i]);
        V[l[i]].push_back(d[i]);sum+=d[i];
    }
    for(int i=1;i<=maxl;i++)
        if(V[i].size())
        {
            cnt+=V[i].size();
            for(int j=0;j<V[i].size();j++) sum-=V[i][j];
            if(cnt>V[i].size()) add=ask(1,1,maxd,cnt-V[i].size()*2+1);
            else add=0;
            ans=min(ans,sum+add);
            for(int j=0;j<V[i].size();j++) change(1,1,maxd,V[i][j]);
        }
    printf("%lld\n",ans);
    return 0;
}

C-金牌赛事

这是一道线段树优化DP。

设 $dp_i$ 表示前 $i$ 条道路修若干条可得到的最大利润，那么我们枚举一个 $j$，则 $i$ 从两种情况转移：
1.若第 $i$ 条不修，则 $dp_i=dp_{i-1}$；
2.若第 $i$ 条要修，则 $dp_i=dp_{j}+val_{j+1,i}-cost_{j+1,i}$；
然而显然现在 $\mathcal{O}(n^2)$ 是不够的，且 $val$ 的处理也很麻烦，耗费时间和空间巨量。

所以我们来观察一下，第二种情况的转移是从一段区间里选最大值，那么我们可以用线段树优化成 $\mathcal{O}(\log n)$。
同时，对于在线段树上算贡献也更好操作：
1.将每一个赛道右端点对应的左端点与贡献存在 vector 里面；
2.在往右扫到第 $i$ 个时，在线段树上将区间 $[0,i-1]$ 都剪掉花费 $c_i$；
3.在往右扫到第 $i$ 个时，将右端点为 $i$ 的赛道挑出来，其左端点为 $l$，贡献为 $p$，在线段树上将区间 $[0,l-1]$ 加上贡献 $p$；
4.在每次枚举结束后，将 $dp_i$ 加到线段树上对应的位置 $i$ 上。

区间修改，区间查询，时间复杂度 $\mathcal{O}(n\log n)$。

点击查看代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int MAXN=2e5+5;
const int INF=0x7f7f7f7f7f7f7f7f;
 
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch))
    {
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(isdigit(ch))
    {
        x=(x<<1)+(x<<3)+(ch^48);
        ch=getchar();
    }
    return x*f;
}
 
struct Node
{
    int l,p;
};
 
int t[MAXN<<2],dat[MAXN<<2];
 
inline void pushup(int p)
{
    t[p]=max(t[p<<1],t[p<<1|1]);
    return;
}
 
inline void addtag(int p,int l,int r,int k)
{
    t[p]+=k,dat[p]+=k;
    return;
}
 
inline void pushdown(int p,int l,int r)
{
    if(dat[p])
    {
        int mid=(l+r)>>1;
        addtag(p<<1,l,mid,dat[p]);
        addtag(p<<1|1,mid+1,r,dat[p]);
        dat[p]=0;
    }
    return;
}
 
inline void change(int p,int l,int r,int a,int b,int k)
{
    if(l>=a && r<=b)
    {
        addtag(p,l,r,k);
        return;
    }
    int mid=(l+r)>>1;
    pushdown(p,l,r);
    if(a<=mid) change(p<<1,l,mid,a,b,k);
    if(b>mid) change(p<<1|1,mid+1,r,a,b,k);
    pushup(p);
    return;
}
 
inline int ask(int p,int l,int r,int a,int b)
{
    if(l>=a && r<=b) return t[p];
    int mid=(l+r)>>1,ans=-INF;
    if(a<=mid) ans=max(ans,ask(p<<1,l,mid,a,b));
    if(b>mid) ans=max(ans,ask(p<<1|1,mid+1,r,a,b));
    return ans;
}
 
int dp[MAXN],c[MAXN];
int n,m;
vector<Node>V[MAXN];
 
signed main()
{
    n=read(),m=read();
    for(int i=1;i<=n;i++) c[i]=read();
    for(int i=1;i<=m;i++)
    {
        int L=read(),R=read(),P=read();
        V[R].push_back({L,P});
    }
    for(int i=1;i<=n;i++)
    {
        change(1,0,n,0,i-1,-c[i]);
        for(int j=0;j<V[i].size();j++)
        {
            int l=V[i][j].l,p=V[i][j].p;
            change(1,0,n,0,l-1,p);
        }
        dp[i]=max(dp[i-1],ask(1,0,n,0,i-1));
        change(1,0,n,i,i,dp[i]);
    }
    printf("%lld\n",dp[n]);
    return 0;
}

D-公园晨跑

首先看到环，就得断环成链。

要求最大值，考虑分 $$两部分分别最大化

距离可以前缀和预处理出来，那么就变成 $sum_y-sum_x+2h_x+2h_y$，为了好处理将相同位置的值放一起然后加括号 $sum_y+2h_y-(sum_x-2h_x)$。

那么就变成了两个 RMQ 问题，没有修改，用线段树维护可行。

但是有一个重要的点，就是有可能出现查到的最大与最小的位置是同一个，这不符合要求，所以我们线段树维护的是下标而不是具体算出来的值，这方便最后处理时，若有重合，那么就往 $[l,pos-1],[pos+1,r]$ 左右两个区间去查，这里 $pos$ 是重合的那个下标。

点击查看代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int MAXN=2e5+5;
const int INF=0x7f7f7f7f7f7f7f7f;
 
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch))
    {
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(isdigit(ch))
    {
        x=(x<<1)+(x<<3)+(ch^48);
        ch=getchar();
    }
    return x*f;
}
 
int n,m;
int d[MAXN],h[MAXN];
int maxn[MAXN<<2],minn[MAXN<<2];
int summax[MAXN],summin[MAXN];
 
inline int getmax(int x,int y)
{
    return summax[x]>summax[y]?x:y;
}
 
inline int getmin(int x,int y)
{
    return summin[x]<summin[y]?x:y;
}
 
inline void pushup(int p)
{
    maxn[p]=getmax(maxn[p<<1],maxn[p<<1|1]);
    minn[p]=getmin(minn[p<<1],minn[p<<1|1]);
    return;
}
 
inline void build(int p,int l,int r)
{
    if(l==r)
    {
        maxn[p]=minn[p]=l;
        return;
    }
    int mid=(l+r)>>1;
    build(p<<1,l,mid);build(p<<1|1,mid+1,r);
    pushup(p);
    return;
}
 
inline int askmax(int p,int l,int r,int a,int b)
{
    if(l>=a && r<=b) return maxn[p];
    int mid=(l+r)>>1,ans=0;
    if(a<=mid) ans=askmax(p<<1,l,mid,a,b);
    if(b>mid) ans=getmax(ans,askmax(p<<1|1,mid+1,r,a,b));
    return ans;
}
 
inline int askmin(int p,int l,int r,int a,int b)
{
    if(l>=a && r<=b) return minn[p];
    int mid=(l+r)>>1,ans=0;
    if(a<=mid) ans=askmin(p<<1,l,mid,a,b);
    if(b>mid) ans=getmin(ans,askmin(p<<1|1,mid+1,r,a,b));
    return ans;
}
 
inline int calcmax(int x,int y)
{
    if(x>y) return 0;
    return askmax(1,1,n*2+1,x,y);
}
 
inline int calcmin(int x,int y)
{
    if(x>y) return 0;
    return askmin(1,1,n*2+1,x,y);
}
 
inline int solve(int x,int y)
{
    int maxi=calcmax(x,y),mini=calcmin(x,y);
    if(mini!=maxi) return summax[maxi]-summin[mini];
    int maxx=getmax(calcmax(x,maxi-1),calcmax(maxi+1,y));
    int minx=getmin(calcmin(x,mini-1),calcmin(mini+1,y));
    return max(summax[maxi]-summin[minx],summax[maxx]-summin[mini]);
}
 
signed main()
{
    n=read(),m=read();
    for(int i=1;i<=n;i++) d[i+1]=d[i+n+1]=read();
    for(int i=1;i<=n;i++) h[i]=h[i+n]=read();
    int sum=0;summax[0]=-INF,summin[0]=INF;
    for(int i=1;i<=n*2;i++) sum+=d[i],summax[i]=sum+2*h[i],summin[i]=sum-2*h[i];
    build(1,1,n*2+1);
    for(int i=1;i<=m;i++)
    {
        int l=read(),r=read();
        if(l<=r) printf("%lld\n",solve(r+1,n+l-1));
        else printf("%lld\n",solve(r+1,l-1));
    }
    return 0;
}
/*
sum[y]+2*h[y]取max  sum[x]-2*h[x]取min
*/

E-幸运树

看到幸运边，考虑如何特殊处理。

可以将所有幸运边断开，形成若干个（假设是 $m$）连通块 $t_1,t_2,\dots,t_m$，然后有一个显然的结论：两个不同连通块的点之间一定有幸运边。

因为没有要求方案，所以我们就直接用公式算：

$ans_i=\sum\limits_{i=1}^m|t_i|\binom{n-|t_i|}{2}$

点击查看代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int MAXN=1e5+5;
 
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch))
    {
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(isdigit(ch))
    {
        x=(x<<1)+(x<<3)+(ch^48);
        ch=getchar();
    }
    return x*f;
}
 
int n;
 
struct edge
{
    int to,nxt,len;
}e[MAXN<<1];
 
int head[MAXN],cnt;
 
inline void add(int x,int y,int z)
{
    e[++cnt].to=y;
    e[cnt].len=z;
    e[cnt].nxt=head[x];
    head[x]=cnt;
    return;
}
 
inline bool check(int x)
{
    int xx=x;
    while(xx)
    {
        int pos=xx%10;xx/=10;
        if(pos!=4 && pos!=7) return false;
    }
    return true;
}
 
bool vis[MAXN];
int cntt;
 
inline void  dfs(int x)
{
    vis[x]=true;cntt++;
    for(int i=head[x];i;i=e[i].nxt)
    {
        int y=e[i].to,z=e[i].len;
        if(vis[y] || z) continue;
        dfs(y);
    }
    return;
}
 
signed main()
{
    n=read();
    for(int i=1;i<=n-1;i++)
    {
        int x=read(),y=read(),z=read();
        int w=check(z);
        add(x,y,w),add(y,x,w);
    }
    int ans=0;
    for(int i=1;i<=n;i++)
        if(!vis[i])
        {
            cntt=0;dfs(i);
            ans+=cntt*(n-cntt)*(n-cntt-1);
        }
    printf("%lld\n",ans);
    return 0;
}

F-犯罪计划

点击查看代码