“科大讯飞杯”第18届上海大学程序设计联赛春季赛暨高校网络友谊赛

鸽了快一个月的题解

A. 组队比赛 (Nowcoder 5278 A)

题目大意

给定 $a,b,c,d$ ，俩俩分组，使得两组中数的和的差最小。

解题思路

最小最大一组另外的一组即可。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
 
int main(void) {
    ios::sync_with_stdio(false); 
    cin.tie(0); cout.tie(0);
    int a[4];
    cin>>a[0]>>a[1]>>a[2]>>a[3];
    sort(a,a+4);
    int ans=abs(a[0]+a[3]-a[1]-a[2]);
    cout<<ans<<endl;
    return 0;
}

B. 每日一报 (Nowcoder 5278 B)

题目大意

符合条件的结构体排序。

解题思路

符合条件的结构体排序。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
 
const double eps=1e-5;
 
struct data{
    int ri,num;
    double t;
    bool operator < (const data & a){
        if (ri>a.ri) return true;
        if (ri<a.ri) return false;
        if (t-a.t>eps) return true;
        if (t-a.t<eps) return false;
        if (num<a.num) return true;
        return false;
    }
};
 
int main(void) {
    ios::sync_with_stdio(false); 
    cin.tie(0); cout.tie(0);
    vector<data> qwq;
    int n;
    cin>>n;
    double tt;
    for(int r,nu,i=1;i<=n;++i){
        cin>>r>>nu>>tt;
        if (tt-38.0<-eps) continue;
        qwq.push_back({r,nu,tt});
    }
    sort(qwq.begin(),qwq.end());
    cout<<qwq.size()<<endl;
    for(auto i:qwq){
        cout<<i.ri<<' '<<i.num<<' '<<fixed<<setprecision(1)<<i.t<<endl;
    }
    return 0;
}

C. 最长非公共子序列 (Nowcoder 5278 C)

题目大意

给定 $s_{1},s_{2}$ ，求出最长的非公共子序列的长度，不存在输出 $-1$ 。

解题思路

相等即为 $-1$ 否则为长度最大的那个。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
 
int main(void) {
    ios::sync_with_stdio(false); 
    cin.tie(0); cout.tie(0);
    string s1,s2;
    cin>>s1>>s2;
    if (s1==s2) cout<<"-1"<<endl;
    else cout<<max(s1.size(),s2.size())<<endl;
    return 0;
}

D. 最大字符集 (Nowcoder 5278 D)

题目大意

给定一个 $n$ ，求一个集合，满足以下条件：

每个字符串由 0 和 1 组成。
每个字符串长度在 1 到 n 之间，且两两长度不同。
集合中任何一个字符串都不是其他字符串的子串。

最大化集合元素个数，输出任意一种可能的集合情况。

解题思路

构造题。 $1,2$ 特殊处理，其余的最大个数为 $n-1$ ，长度从 $2$ 到 $n$ ，每个元素首尾为 $1$ 中间为 $0$ 。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
 
int main(void) {
    ios::sync_with_stdio(false); 
    cin.tie(0); cout.tie(0);
    int n;
    cin>>n;
    if (n==1){
        cout<<"1"<<endl;
        cout<<"1"<<endl;
    }else if (n==2){
        cout<<"2"<<endl;
        cout<<"1"<<endl;
        cout<<"00"<<endl;
    }else{
        cout<<n-1<<endl;
        for(int i=2;i<=n;++i){
            string s(i,'0');
            s[0]='1';
            s[i-1]='1';
            cout<<s<<endl;
        }
    }
    return 0;
}

E. 美味的序列 (Nowcoder 5278 E)

题目大意

给定一个序列，每次可以从头或尾取一个数，每次取后序列里的所有数减一。问最优的取法，取出来的数的和是多少。

解题思路

很容易发现怎么取结果都是一样的（将减一操作作用在另一个初始全为0的数组），于是答案就是所有数的和减去 $\frac{n(n-1)}{2}$ 。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
 
int main(void) {
    ios::sync_with_stdio(false); 
    cin.tie(0); cout.tie(0);
    int n;
    cin>>n;
    LL ans=-(LL)(n)*(n-1)/2;
    LL qwq=0;
    while(n--){
        cin>>qwq;
        ans+=qwq;
    }
    cout<<ans<<endl;
    return 0;
}

F. 日期小助手 (Nowcoder 5278 F)

题目大意

给定一个日期，输出该日期后最近的母亲节或父亲节是什么时候。

解题思路

求出当前年和下一年的母亲父亲节日期比较即可。
恰好练一练类。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
 
struct data{
    int y,m,d;
    bool operator < (const data & a){
        if (y<a.y) return true;
        if (y>a.y) return false;
        if (m<a.m) return true;
        if (m>a.m) return false;
        if (d<a.d) return true;
        if (d>a.d) return false;
        return false;
    }
};
 
 
int run[108]={0};
 
bool check(int y){
    if (y%400==0) return true;
    if (y%100!=0&&y%4==0) return true;
    return false;
}
 
pair<data,data> solve(int y){
    int x=6-(y-2000+run[y-2000]);
    int xx=3-(y-2000+run[y-2000]);
    while(x<0){
        x+=7;
    }
    while(xx<0){
        xx+=7;
    }
    data a={y,5,x+8};
    data b={y,6,xx+15};
    return (make_pair(a,b));
}
 
 
int main(void) {
    ios::sync_with_stdio(false); 
    cin.tie(0); cout.tie(0);
    for(int i=1;i<=105;++i)
        if (check(i+2000)) run[i]++;
    for(int i=1;i<=101;++i) run[i]+=run[i-1];
    int t;
    cin>>t;
    while(t--){
        data noww;
        cin>>noww.y>>noww.m>>noww.d;
        auto qwq=solve(noww.y);
        auto qaq=solve(noww.y+1);
        if (noww<qwq.first){
            cout<<"Mother's Day: May "<<qwq.first.d<<"th, "<<qwq.first.y<<endl;
        }else if (noww<qwq.second){
            cout<<"Father's Day: June "<<qwq.second.d;
            if (qwq.second.d==21) cout<<"st, ";
            else cout<<"th, ";
            cout<<qwq.second.y<<endl;
        }else{
            cout<<"Mother's Day: May "<<qaq.first.d<<"th, "<<qaq.first.y<<endl;
        }
    }
    return 0;
}

G. 血压游戏 (Nowcoder 5278 G)

题目大意

给定一棵树，根的编号是 $s$ （从 $1$ 开始）,每个节点有 $a_i$ 只松鼠，它们不断向根节点移动，且会依次发生以下事件：

如果一个节点上有 2 只或 2 只以上的松鼠，他们会打架，然后这个节点上松鼠的数量会减少 1；
根节点的所有松鼠移动到地面，位于地面上的松鼠不会再打架；
所有松鼠同时朝它们的父节点移动。

问最终有多少只松鼠到达地面。

解题思路

容易发现不同深度之间的松鼠互不干扰，所以我们每次就针对同一深度的松鼠考虑。

$dp[i]$ 表示到达节点 $i$ 的松鼠数量，很容易可以转移，但每个深度的求解复杂度是 $O(n)$ ，最坏情况即链为 $O(n^{2})$ 会炸。

但我们发现松鼠在往根跑的时候好多情况是一样的（即减少的松鼠数为深度的减少数），只是在多处松鼠的所谓的"汇聚点"即 $LCA$ 处会发生变化。于是我们可以可以把树压缩，保留那些关键的转移点（即 $LCA$ ），去掉那些可以预知变化的点（即起始点到LCA间的点）。

其实这就是要建一棵虚树，用栈维护当前建的一条从根节点开始的链。虚树 $DP$ 。

最终复杂度即为 $O(n)$ 。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
 
template <typename T>
void read(T &x) {
    int s = 0, c = getchar();
    x = 0;
    while (isspace(c)) c = getchar();
    if (c == 45) s = 1, c = getchar();
    while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
    if (s) x = -x;
}
 
template <typename T>
void write(T x, char c = ' ') {
    int b[40], l = 0;
    if (x < 0) putchar(45), x = -x;
    while (x > 0) b[l++] = x % 10, x /= 10;
    if (!l) putchar(48);
    while (l) putchar(b[--l] | 48);
    putchar(c);
}
 
struct data{
    int deep,t,id;
 
    bool operator < (const data & a) const{
        if (deep<a.deep) return true;
        if (deep>a.deep) return false;
        if (t<a.t) return true;
        return false;
    }
};
 
const int N=2e5+8;
 
vector<data> po;
 
vector<int> edge[N];
 
int up[N][32];
 
LL dp[N];
 
int deep[N];
 
int n,s,t;
 
LL cnt[N];
 
LL ans;
 
void DFS(int u,int fa){
    deep[u]=deep[fa]+1;
    po.push_back({deep[u],++t,u});
    up[u][0]=fa;
    for(auto v:edge[u]){
        if (v==fa) continue;
        DFS(v,u);
    }
}
 
int lca(int u,int v){
    if (u==v) return u;
    if (deep[u]<deep[v]) swap(u,v);
    for(int i=31;i>=0;--i){
        if (deep[up[u][i]]>=deep[v])
            u=up[u][i];
    }
    if (u==v) return u;
    for(int i=31;i>=0;--i){
        if (up[u][i]!=up[v][i]){
            u=up[u][i];
            v=up[v][i];
        }
    }
    return up[u][0];
}
 
int st[N],top;
 
int head[N],to[N*2],nxt[N*2],num;
 
void add(int u,int v){
    num++;
    nxt[num]=head[u];
    to[num]=v;
    head[u]=num;
}
 
void DP(int u,int fa){
    for(int v,i=head[u];i;i=nxt[i]){
        v=to[i];
        if (v==fa) continue;
        DP(v,u);
        if (dp[v]) dp[u]+=max(1ll,dp[v]-deep[v]+deep[u]+1);
        dp[v]=0;
        head[u]=0;
    }
    if (dp[u]) dp[u]=max(1ll,dp[u]-1);
}
 
void solve(int l,int r){
    num=0;
    top=0;
    st[top]=s;
    int la=s;
    for(int i=l;i<=r;++i){
        dp[po[i].id]=cnt[po[i].id];
        int cur=po[i].id;
        int fa=lca(la,cur);
        while(top>0&&deep[st[top-1]]>=deep[fa]){
            add(st[top-1],st[top]);
            --top;
        }
        if (st[top]!=fa){
            add(fa,st[top]);
            st[top]=fa;
        }
        st[++top]=cur;
        la=cur;
    }
    while(top>0){
        add(st[top-1],st[top]);
        --top;
    }
    DP(s,s);
    ans+=dp[s];
    dp[s]=0;
}
 
int main(){
    read(n);
    read(s);
    for(int i=1;i<=n;++i) read(cnt[i]);
    for(int u,v,i=1;i<n;++i){
        read(u);
        read(v);
        edge[u].push_back(v);
        edge[v].push_back(u);
    }
    DFS(s,s);
    for(int i=1;i<=31;++i)
        for(int j=1;j<=n;++j)
            up[j][i]=up[up[j][i-1]][i-1];
    sort(po.begin(),po.end());
    int l=1;
    if (cnt[po[0].id]) ans=max(1ll,cnt[po[0].id]-1);
    for(int i=2;i<n;++i){
        if (po[i].deep!=po[i-1].deep){
            solve(l,i-1);
            l=i;
        }
    }
    solve(l,n-1);
    write(ans,'\n');
}

H. 纸牌游戏 (Nowcoder 5278 H)

题目大意

给定长度为 $n$ 的数字串，每个数字 $0$ 到 $9$ ，要求从中选取 $k$ 个数字组成一个非负整数，使得它可以被 $3$ 整除且最大。

解题思路

首先对数字串中的数字从大到小排序，然后设 $dp[i][j][k]$ 表示当前第 $i$ 个数，还可以取 $j$ 个数，当前选的数组成的数对 $3$ 取模为 $k$ ，后继是否存在可行方案（记忆化搜索，含义似乎难以描述qwq），转移就看这第 $i$ 个数选或不选两种方式。时间复杂度 $O(nk)$ 爆了空间和时间。

稍加思索会发现我们定义的状态里有好多***冗余重复 ***的状态，如 $9999$ ，我们会考虑了多次选 $1$ 个 $9$ 或 $2$ 个 $9$ 的情况或 $3$ 个 $9$ 的情况，于是我们改变定义方式为 $dp[i][j][k]$ 为当前考虑选择数字 $i$ （从9开始考虑），还有 $j$ 个可以选，对 $3$ 取模为 $k$ 后继是否存在可行方案，转移即可。时间复杂度 $O(9n*3)$ 。

特判全是 $0$ 且 $k\neq 1$ 的情况。

多组数据，不能每组 $memset$ ，于是玄学操作——自定义真假未定义。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
template <typename T>
void read(T &x) {
    int s = 0, c = getchar();
    x = 0;
    while (isspace(c)) c = getchar();
    if (c == 45) s = 1, c = getchar();
    while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
    if (s) x = -x;
}
 
template <typename T>
void write(T x, char c = ' ') {
    int b[40], l = 0;
    if (x < 0) putchar(45), x = -x;
    while (x > 0) b[l++] = x % 10, x /= 10;
    if (!l) putchar(48);
    while (l) putchar(b[--l] | 48);
    putchar(c);
}
 
const int N=1e5+8;
 
char s[N];
 
int cc[10];
 
int tt=0;
 
int dp[10][N][3];
 
int sum[10];
 
bool DFS(int num,int k,int mo,int cnt[]){
    if (k==0) return mo==0;
    if (num<0) return false;
    if (k>sum[num]) return false; //可行性剪枝
    if (dp[num][k][mo]>tt) return dp[num][k][mo]==tt+2;
    for(int i=min(cnt[num],k);i>=0;--i){
        if (DFS(num-1,k-i,(mo+num*i)%3,cnt)){
            cc[num]=i;
            dp[num][k][mo]=tt+2;
            return true;
        }
    }
    dp[num][k][mo]=tt+1;
    return false;
}
 
int main(void) {
    int kase; read(kase);
    for (int ii = 1; ii <= kase; ii++){
        scanf("%s",s);
        int k;
        read(k);
        int cnt[10]={0};
        int len=strlen(s);
        for(int i=0;i<len;++i)
            cnt[s[i]-'0']++;
        for(int i=0;i<10;++i) cc[i]=0;
        sum[0]=cnt[0];
        for(int i=1;i<10;++i) sum[i]=cnt[i]+sum[i-1];
        bool qwq=DFS(9,k,0,cnt);
        if (qwq&&(cc[0]!=k||k==1)){
            char ans[k+1]={0};
            int cr=0;
            for(int i=9;i>=0;--i){
                while(cc[i]){
                    ans[cr++]=i+'0';
                    cc[i]--;
                }
            }
            printf("%s\n",ans);
        }else puts("-1");
        tt+=3;
    }
    return 0;
}

I. 古老的打字机 (Nowcoder 5278 I)

题目大意

给定 $n$ 个串 $s_{i}$ 以及对应的价值 $v_{i}$ ，现在会敲击打字机 $m$ 次，每次会等概率的敲击出一个小写字母或者退格键，退格键的作用是将当前得到的字符串的最后一个字母删除，当然如果当前是空串，则无事发生。问得到的字符串 $t$ 的价值的期望的 $27^{m}$ 倍是多少。

字符串 $t$ 的价值定义为：每个串 $s_i$ 在得到的串t中的出现次数 $c_i$ 与价值 $v_i$ 的乘积,即 $\sum\limits_{k=1}^{n} \sum\limits_{i=1}^{|t|} \sum\limits_{j=1}^{|t|}v_{k}[s_k=substr(t,i,j)]$ .

解题思路

根据期望的定义，答案就是 $\frac{\text{乱七八糟}}{27^{m}}$ ，我们现在考虑乱七八糟怎么算。

乱七八糟就是全部可能的字符串乘以对应的价值，直接计算的复杂度是 $27^{m}$ 。我们考虑如何合并。

我们先按长度进行分类，对于同一长度的字符串 $t$ ，它在 $27^{m}$ 的情况中出现的次数都是一样的。这一长度的总价值计算，从得到的字符串 $t$ 来考虑显然不现实，我们就经典转换成考虑每个 $s_{i}$ 对该长度总价值的贡献。

设当前考虑的字符串长度为 $l$ ，对于一个长度为 $|s_{i}|$ 小于等于 $l$ 的串 $s_{i}$ ，它对字符串 $t$ 长度为 $l$ 时的总价值贡献就为 $v_{i} \times (l-|s_{i}|+1) \times 26^{l-|s_{i}|}\times \dfrac{dp[m][l]}{26^{l}}$ 。

$dp[m][l]$ 表示敲击 $m$ 次，得到串 $t$ 长度为 $l$ 的方案数。这个一开始预处理即可得到。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
template <typename T>
void read(T &x) {
    int s = 0, c = getchar();
    x = 0;
    while (isspace(c)) c = getchar();
    if (c == 45) s = 1, c = getchar();
    while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
    if (s) x = -x;
}
 
template <typename T>
void write(T x, char c = ' ') {
    int b[40], l = 0;
    if (x < 0) putchar(45), x = -x;
    while (x > 0) b[l++] = x % 10, x /= 10;
    if (!l) putchar(48);
    while (l) putchar(b[--l] | 48);
    putchar(c);
}
 
const LL mo=1e9+7;
 
const int N=1e3+8;
 
int n,m;
 
int len[N];
 
LL val[N];
 
LL ans;
 
LL dp[N][N];
 
LL p26[N];
 
char s[N];
 
LL qpower(LL a,LL b){
    LL qwq=1;
    while(b){
        if (b&1) qwq=qwq*a%mo;
        b>>=1;
        a=a*a%mo;
    }
    return qwq;
}
 
LL inv(LL x){
    return qpower(x,mo-2);
}
 
int main(void) {
    read(n);
    read(m);
    for(int i=1;i<=n;++i){
        scanf("%s",s);
        len[i]=strlen(s);
        read(val[i]);
    }
    p26[0]=1;
    for(int i=1;i<=1004;++i) p26[i]=p26[i-1]*26ll%mo;
    dp[0][0]=1;
    for(int i=1;i<=m;++i)
        for(int j=0;j<=i;++j){
            if (j==0) dp[i][j]=(dp[i-1][j]+dp[i-1][j+1])%mo;
            else if (j>=i-1) dp[i][j]=dp[i-1][j-1]*26ll%mo;
            else dp[i][j]=(dp[i-1][j-1]*26ll%mo+dp[i-1][j+1])%mo;
        }
    LL tmp=1;
    LL qwq=1;
    for(int i=0;i<=m;++i){
        for(int j=1;j<=n;++j){
            if (len[j]>i) continue;
            ans=(ans+(i-len[j]+1ll)*p26[i-len[j]]%mo*val[j]%mo*dp[m][i]%mo*qwq%mo)%mo;
        }
        tmp=tmp*26%mo;
        qwq=inv(tmp);
    }
    write(ans,'\n');
    return 0;
}

J. 能到达吗 (Nowcoder 5278 J)

题目大意

给定一张 $n*m$ 的图，左上角坐标 $(1,1)$ ，右下角坐标 $(n,m)$ ，有 $k$ 个障碍物，第 $i$ 个障碍物坐标为 $(x_{i},y_{i})$ 。你可以在空地上上下左右走动，但不能跳出边界。问俩俩能到达的无序点对（即从一个点可以到达另外一个点）有多少。答案模 $1e9+7$ 。

解题思路

很显然，如果一个连通块有 $cnt$ 个点，那么这个连通块对答案的贡献就为 $\dfrac{cnt*(cnt-1)}{2}+cnt$ ，我们考虑如何求出每个连通块中的点数。

由于 $n,m \leq 2 \cdot 10^{5}$ ，而 $k \leq 10^{6}$ ，我们用一根扫描线对这张图从上往下扫描，当前第 $i$ 行，在该行的障碍物把该行分成了若干条互不相交的线段，这些线段归属于哪个连通块我们可以用并查集维护。

然后考虑第 $i+1$ 行，在该行的障碍物也把该行分成了若干条互不相交的线段，现在我们对第 $i$ 行和第 $i+1$ 行的线段进行合并，这里的合并指的是连通块的合并，即如果这两行中的两条线段是相交的，则它们应属于同一连通块，合并完后我们拿第 $i+1$ 行的线段与 $i+2$ 行的线段继续合并即可。合并的过程就是一个模拟的过程。

对于该行没有障碍物的，则视为一条线段，如果有连续若干行无障碍物，这我们可以把这若干行压成一行，视为一条线段，与前一行或后一行合并。

特殊处理无障碍物的情况。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
template <typename T>
void read(T &x) {
    int s = 0, c = getchar();
    x = 0;
    while (isspace(c)) c = getchar();
    if (c == 45) s = 1, c = getchar();
    while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
    if (s) x = -x;
}
 
template <typename T>
void write(T x, char c = ' ') {
    int b[40], l = 0;
    if (x < 0) putchar(45), x = -x;
    while (x > 0) b[l++] = x % 10, x /= 10;
    if (!l) putchar(48);
    while (l) putchar(b[--l] | 48);
    putchar(c);
}
 
const LL mo=1e9+7;
 
const int N=5e6+8;
 
LL n,m,k;
 
int f[N],tot;
 
LL cnt[N];
 
pair<int,int> po[N];
 
struct data{
	int l,r,id;
};
 
vector<data> seg[2];
 
int cur;
 
LL ans;
 
LL inv2;
 
int findfa(int x){
	if (f[x]==x) return x;
	else return f[x]=findfa(f[x]);
}
 
bool check(data & a,data & b){
	return a.r>=b.l&&a.l<=b.r;
}
 
void unionn(){
	if (seg[cur^1].empty()) return;
	int l=0;
	for(auto & i:seg[cur]){
		while(true){
			if (l<(int)seg[cur^1].size()&&check(i,seg[cur^1][l])){
				int fa=findfa(i.id);
				int fb=findfa(seg[cur^1][l].id);
				if (fa!=fb){
					f[fa]=fb;
					cnt[fb]=(cnt[fb]+cnt[fa])%mo;
				}
				++l;
			}else{
                if (l==(int)seg[cur^1].size()||seg[cur^1][l].l>i.r){
                    l=max(l-1,0);
                    break;
                }else ++l;
			}
		}
	}
}
 
void work(int u,int d){
    if (u>d) return;
	cur^=1;
	while(!seg[cur].empty()) seg[cur].pop_back();
	++tot;
	f[tot]=tot;
	cnt[tot]=(LL)(d-u+1ll)*m%mo;
	seg[cur].push_back({1,(int)m,tot});
	unionn();
}
 
void solve(int l,int r){
    if (l>r) return;
	int la=0;
	cur^=1;
    while(!seg[cur].empty()) seg[cur].pop_back();
	for(int i=l;i<=r;++i){
		if (po[i].second-la>1){
			++tot;
			f[tot]=tot;
			cnt[tot]=po[i].second-la-1;
			seg[cur].push_back({la+1,po[i].second-1,tot});
		}
		la=po[i].second;
	}
	if (m>la){
		++tot;
		f[tot]=tot;
		cnt[tot]=m-la;
		seg[cur].push_back({la+1,(int)m,tot});
	}
	unionn();
}
 
LL qpower(LL a,LL b){
	LL qwq=1;
	while(b){
		if (b&1) qwq=qwq*a%mo;
		b>>=1;
		a=a*a%mo;
	}
	return qwq;
}
 
LL inv(LL x){
	return qpower(x,mo-2);
}
 
int main(void) {
    int kase; read(kase);
    inv2=inv(2);
    for (int ii = 1; ii <= kase; ii++){
        tot=0;
        ans=0;
        while(!seg[0].empty()) seg[0].pop_back();
        while(!seg[1].empty()) seg[1].pop_back();
        read(n);
        read(m);
        read(k);
        if (k==0) ans=((n*m%mo)*((n*m-1ll)%mo)%mo*inv2%mo+n*m%mo)%mo;
        else{
            for(int i=1;i<=k;++i) read(po[i].first),read(po[i].second);
            sort(po+1,po+1+k);
            int la=0;
            int l=1;
            work(1,po[1].first-1);
            la=po[1].first;
            for(int i=2;i<=k;++i){
                if (po[i].first!=la){
                    solve(l,i-1);
                    if (po[i].first-la>1) work(la+1,po[i].first-1);  //有空行
                    l=i;
                    la=po[i].first;
                }
            }
            solve(l,k);
            la=po[k].first;
            if (n>la){
                work(la+1,n);
            }
            for(int i=1;i<=tot;++i){
                if (f[i]==i){
                    ans=(ans+cnt[i]*(cnt[i]-1)%mo*inv2%mo+cnt[i])%mo;
                }
            }
        }
        write(ans,'\n');
        }
    return 0;
}

K. 迷宫 (Nowcoder 5278 K)

题目大意

图上一些地方有障碍物 $X$ ，有一个地方是起点 $S$ ，有一个地方是终点 $T$ 。现要求从起点移动到终点，一次操作可以上下左右移动一格，但不能超出边界。同时给定一个整数 $d$ ，可以使用一次技能，即从当前点 $a$ 移动到另一点 $b$ ，两点的切比雪夫（横坐标差与纵坐标差的最大值）距离不得大于 $d$ ，使用一次技能算一步操作。问从起点到终点的最小操作次数，并输出一种可行移动方案。

解题思路

切比雪夫距离对应的就是一个正方形的范围。

我们从起点开始BFS，再从终点开始BFS，记录每个点到起点和终点的距离。

然后再枚举一个边长为 $d+1$ 的正方形范围，设这个范围中到起点的最小值为 $s$ 和到终点的最小值 $t$ ，则在该范围使用技能后的最小操作次数就是 $s+t+1$ ，对所有范围取最小值即为答案。

至于维护二维正方形的最小值，用两次单调队列即可。先对行的每个数维护它右边 $d$ 个的最小值，再对每一列，用这个最小值，维护每行向下 $d$ 个数的最小值。

至于输出方案，再记录前驱和取得的最小值的位置吧。

特殊处理 $d=0$ 的情况。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
template <typename T>
void read(T &x) {
    int s = 0, c = getchar();
    x = 0;
    while (isspace(c)) c = getchar();
    if (c == 45) s = 1, c = getchar();
    while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
    if (s) x = -x;
}
 
template <typename T>
void write(T x, char c = ' ') {
    int b[40], l = 0;
    if (x < 0) putchar(45), x = -x;
    while (x > 0) b[l++] = x % 10, x /= 10;
    if (!l) putchar(48);
    while (l) putchar(b[--l] | 48);
    putchar(c);
}
 
const int N=2e3+8;
 
const int dx[4]={0,0,1,-1};
 
const int dy[4]={-1,1,0,0};
 
struct data{
    int val;
    int x,y;
 
    bool operator < (const data & a) const{
        return val<a.val;
    }
 
    operator int(){
        return val;
    }
}st[N][N],en[N][N],ast,aen;
 
char ma[N][N];
 
int n,m,d;
 
int ans;
 
int sx,sy,ex,ey;
 
pair<int,int> pre_st[N][N],pre_en[N][N];
 
void BFS_st(){
    st[sx][sy].val=0;
    pre_st[sx][sy]=make_pair(sx,sy);
    queue<pair<int,int>> team;
    team.push(make_pair(sx,sy));
    while(!team.empty()){
        auto u=team.front();
        team.pop();
        for(int i=0;i<4;++i){
            auto v=make_pair(u.first+dx[i],u.second+dy[i]);
            if (ma[v.first][v.second]=='X') continue;
            if (st[v.first][v.second]>st[u.first][u.second]+1){
                st[v.first][v.second].val=st[u.first][u.second].val+1;
                team.push(v);
                pre_st[v.first][v.second]=u;
            }
        }
    }
}
 
void BFS_en(){
    en[ex][ey].val=0;
    pre_en[ex][ey]=make_pair(ex,ey);
    queue<pair<int,int>> team;
    team.push(make_pair(ex,ey));
    while(!team.empty()){
        auto u=team.front();
        team.pop();
        for(int i=0;i<4;++i){
            auto v=make_pair(u.first+dx[i],u.second+dy[i]);
            if (ma[v.first][v.second]=='X') continue;
            if (en[v.first][v.second]>en[u.first][u.second]+1){
                en[v.first][v.second].val=en[u.first][u.second].val+1;
                team.push(v);
                pre_en[v.first][v.second]=u;
            }
        }
    }
}
 
void pre_s(){
    deque<data> team;
    for(int i=1;i<=n;++i){
        for(int j=1;j<=min(m,d+1);++j){
            while(!team.empty()&&team.back()>=st[i][j]) team.pop_back();
            team.push_back(st[i][j]);
        }
        st[i][1]=team.front();
        for(int j=min(m,d+1)+1;j<=m;++j){
            while(!team.empty()&&team.front().y<j-d) team.pop_front();
            while(!team.empty()&&team.back()>=st[i][j]) team.pop_back();
            team.push_back(st[i][j]);
            st[i][j-d]=team.front();
 
        }
        while(!team.empty()) team.pop_back();
    }
    for(int i=1;i<=max(1,m-d);++i){
        for(int j=1;j<=min(n,d+1);++j){
            while(!team.empty()&&team.back()>=st[j][i]) team.pop_back();
            team.push_back(st[j][i]);
        }
        st[1][i]=team.front();
        for(int j=min(n,d+1)+1;j<=n;++j){
            while(!team.empty()&&team.front().x<j-d) team.pop_front();
            while(!team.empty()&&team.back()>=st[j][i]) team.pop_back();
            team.push_back(st[j][i]);
            st[j-d][i]=team.front();
        }
        while(!team.empty()) team.pop_back();
    }
}
 
void pre_e(){
    deque<data> team;
    for(int i=1;i<=n;++i){
        for(int j=1;j<=min(m,d+1);++j){
            while(!team.empty()&&team.back()>=en[i][j]) team.pop_back();
            team.push_back(en[i][j]);
        }
        en[i][1]=team.front();
        for(int j=min(m,d+1)+1;j<=m;++j){
            while(!team.empty()&&team.front().y<j-d) team.pop_front();
            while(!team.empty()&&team.back()>=en[i][j]) team.pop_back();
            team.push_back(en[i][j]);
            en[i][j-d]=team.front();
 
        }
        while(!team.empty()) team.pop_back();
    }
    for(int i=1;i<=max(1,m-d);++i){
        for(int j=1;j<=min(n,d+1);++j){
            while(!team.empty()&&team.back()>=en[j][i]) team.pop_back();
            team.push_back(en[j][i]);
        }
        en[1][i]=team.front();
        for(int j=min(n,d+1)+1;j<=n;++j){
            while(!team.empty()&&team.front().x<j-d) team.pop_front();
            while(!team.empty()&&team.back()>=en[j][i]) team.pop_back();
            team.push_back(en[j][i]);
            en[j-d][i]=team.front();
        }
        while(!team.empty()) team.pop_back();
    }
}
 
void print_st(int x,int y){
    if (x==sx&&y==sy){
        printf("%d %d\n",sx-1,sy-1);
        return;
    }
    print_st(pre_st[x][y].first,pre_st[x][y].second);
    printf("%d %d\n",x-1,y-1);
}
 
void print_en(int x,int y){
    if (x!=ast.x||y!=ast.y) printf("%d %d\n",x-1,y-1);
    if (x==ex&&y==ey) return;
    int tmp=x;
    x=pre_en[tmp][y].first;
    y=pre_en[tmp][y].second;
    while(x!=ex||y!=ey){
        printf("%d %d\n",x-1,y-1);
        tmp=x;
        x=pre_en[tmp][y].first;
        y=pre_en[tmp][y].second;
    }
    if (x!=ast.x||y!=ast.y) printf("%d %d\n",x-1,y-1);
}
 
int main(){
    read(n);
    read(m);
    read(d);
    for(int i=1;i<=n;++i) scanf("%s",ma[i]+1);
    for(int i=1;i<=n;++i) ma[i][0]=ma[i][m+1]='X';
    for(int i=1;i<=m;++i) ma[0][i]=ma[n+1][i]='X';
    for(int i=1;i<=n;++i) for(int j=1;j<=m;++j){
        if (ma[i][j]=='S'){ sx=i; sy=j;}
        if (ma[i][j]=='T'){ ex=i; ey=j;}
        st[i][j]=en[i][j]={1000000007,i,j};
    }
    BFS_st();
    BFS_en();
    ans=1e9+7;
    if (d==0){
        for(int i=1;i<=n;++i) 
            for(int j=1;j<=m;++j) 
                if (st[i][j]+en[i][j]<ans){
                    ans=st[i][j]+en[i][j];
                    ast=st[i][j];
                    aen=en[i][j];
                }
    }else{
        pre_s();
        pre_e();
        for(int i=1;i<=max(1,n-d);++i)
            for(int j=1;j<=max(1,m-d);++j)
                if (st[i][j]+en[i][j]+1<ans){
                    ans=st[i][j]+en[i][j]+1;
                    ast=st[i][j];
                    aen=en[i][j];
                }
    }
    if (ans==1000000007) ans=-1;
    write(ans,'\n');
    if (ans!=-1){
        print_st(ast.x,ast.y);
        print_en(aen.x,aen.y);
    }
    return 0;
}

L. 动物森友会 (Nowcoder 5278 L)

题目大意

一周七天，一周的某些天可以执行特定的事件，一天最多执行 $e$ 次事件，同一个事件可以一天可以执行多次。

现在列出要执行的某些事件和且执行该事件的次数，问执行完这些事件所需的最小天数。

解题思路

很显然，当天数足够大时，一定能执行完所有事件。

天数对决策的可行具有单调性，于是我们二分天数，对于一个特定的天数，一周的某些天的执行次数是一定的，我们的任务就是分配这些执行次数，该去执行哪些事件，执行几次，这是带有反悔性质的抉择，跑一遍网络流即可。

神奇的代码

 #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
template <typename T>
void read(T &x) {
    int s = 0, c = getchar();
    x = 0;
    while (isspace(c)) c = getchar();
    if (c == 45) s = 1, c = getchar();
    while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
    if (s) x = -x;
}
 
template <typename T>
void write(T x, char c = ' ') {
    int b[40], l = 0;
    if (x < 0) putchar(45), x = -x;
    while (x > 0) b[l++] = x % 10, x /= 10;
    if (!l) putchar(48);
    while (l) putchar(b[--l] | 48);
    putchar(c);
}
 
const int N=2e4+8;
 
const int INF=1e9+7;
 
int head[N],nxt[N*2],to[N*2],team[N*2],dis[N*2];
 
LL b_flow[N*2],flow[N*2];
 
int n,e,st,en,num;
 
LL sum;
 
void add(int u, int v, int w) {
	num++;
	nxt[num] = head[u];
	to[num] = v;
	flow[num] = w;
	head[u] = num;
	num++;
	nxt[num] = head[v];
	to[num] = u;
	flow[num] = 0;
	head[v] = num;
}
 
bool BFS() {
	int l = 0, r = 1;
	team[1] = st;
	memset(dis, 0, sizeof(dis));
	dis[st] = 1;
	while (l < r) {
		int u = team[++l];
		for (int v, i = head[u]; i; i = nxt[i]) {
			v = to[i];
			if (dis[v] == 0 && flow[i]) {
				dis[v] = dis[u] + 1;
				team[++r] = v;
			}
		}
	}
	if (dis[en]) return true;
	else return false;
}
 
LL DFS(int u, LL f) {
	if (u == en) return f;
	LL qwq = 0, tmp = 0;
	for (int v, i = head[u]; i; i = nxt[i]) {
		v = to[i];
		if (dis[v] == dis[u] + 1 && flow[i]) {
			qwq = DFS(v, min(f - tmp, flow[i]));
			flow[i] -= qwq;
			flow[i ^ 1] += qwq;
			tmp += qwq;
			if (tmp == f) return tmp;
		}
	}
	return tmp;
}
 
bool check(int x){
    for(int i=2;i<=num;++i) flow[i]=b_flow[i];
    for(int i=head[st];i;i=nxt[i])
        flow[i]=(LL)((x-1)/7+((x-1)%7>=to[i]-1))*(LL)e;
    LL cnt=0;
    while(BFS()){
        cnt+=DFS(st,INF);
    }
    return cnt==sum;
}
 
int main(void) {
    read(n);
    read(e);
    num=1;
    st=0;
    sum=0;
    en=n+8;
    for(int i=1;i<=7;++i)
        add(st,i,0);
    for(int c,m,i=1;i<=n;++i){
        read(c);
        read(m);
        sum+=c;
        add(i+7,en,c);
        for(int v,j=1;j<=m;++j){
            read(v);
            add(v,i+7,INF);
        }
    }
    for(int i=2;i<=num;++i)
        b_flow[i]=flow[i];
    int l=0,r=(sum+1)*8;
    int ans=0;
    while(l+1<r){
        int mid=(l+r)>>1;
        if (check(mid)) ans=mid,r=mid;
        else l=mid;
    }
    printf("%d\n",ans);
    return 0;  
}

本文作者：~Lanly~

本文链接：https://www.cnblogs.com/Lanly/p/12865951.html

posted @ 2020-05-10 23:30 ~Lanly~ 阅读(176) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

公告

昵称：~Lanly~ 园龄：8年3个月粉丝：301 关注：55

昵称： ~Lanly~
园龄： 8年3个月
粉丝： 301
关注： 55

+加关注

指尖跃动的换行符，是我此生不变的信仰。|

2025年3月

日

一

二

三

四

五

六

	#include <bits/stdc++.h>
	using namespace std;
	typedef long long LL;

	int main(void) {
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	int a[4];
	cin>>a[0]>>a[1]>>a[2]>>a[3];
	sort(a,a+4);
	int ans=abs(a[0]+a[3]-a[1]-a[2]);
	cout<<ans<<endl;
	return 0;
	}

指尖跃动的换行符，是我此生不变的信仰。

题目大意

解题思路

题目大意

解题思路

题目大意

解题思路

题目大意

解题思路

题目大意

解题思路

题目大意

解题思路

题目大意

解题思路

题目大意

解题思路

题目大意

解题思路

题目大意

解题思路

题目大意

解题思路

题目大意

解题思路

公告

随笔档案

友情链接