“我在35度的太阳底下 放 寒 假”部分题解

最新推荐文章于 2026-06-20 18:32:07 发布
原创 最新推荐文章于 2026-06-20 18:32:07 发布 · 443 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#算法 #动态规划 #图论
本文精选了算法竞赛中的经典题目并提供详细题解，包括最短路径、动态规划、括号匹配、矩阵涂色等问题，深入解析算法思路，助力算法学习。

这是某次校内赛的部分题解，之所以说“部分”，是因为①E题难度太大，其来源是cf中 *2500 的“Rectangle Painting 2”，我做不了，就将其替换成了 *2300 的 “Rectangle Painting 1”；②G题不想写题解了。

A.Tricks Device [HDU - 5294]

给出一张 n 个点，m 条边的无向图，每条边有边长 wi 。求①最少删去几条边使得从 1 号点到 n 号点的最短路数值变化；②最多删几条边使得从 1 号点到 n 号点的最短路数值不变。 n<=2000, m<=60000, 1<=wi<=100

首先说明，网上很多用网络流做，在我学会网络流之前，就先写一个不用网络流的方法吧。

对于②，只需找到从 1 到 n 的最短路中的最少路数就行了。设最少路数为 num，那么答案为 res2=m-num 。

对于①，稍有难度。首先求出 1 到所有点的单源最短路，借此我们可以得到从 1 到 n 的若干条具体的最短路径，将其再建一张图，这是一张从 1 到 n （或从 n 到 1 ）的有向图。现在，我们只需求出在新图中最少删几条边就能使 1 和 n 不连通。思考后可知，必须要使整个路径在中间的某些点 u1、u2…处断开，使得从起点只能到达 u1、u2等点，而无法到达终点。而且 u1、u2 等点应无法相互到达（若从 u1 能到达 u2 ，那只删 u1 或只删 u2 不就行了吗）。于是便有了一个利用拓扑序求解的好办法：

首先，建立由最短路径组成的新图：

//我的这个图是从 1 到 n 的有向图
q2.push(n);
while(!q2.empty())
{
    int u=q2.front(); q2.pop();
    for(int p=Edge::h[u]; p; p=e[p].next)
    {
        int v=e[p].to;
        if(d[u]==d[v]+e[p].w)
        {
            if(col[v]==0)
            {
                q2.push(v);
                col[v]=1;
            }
            V[v].push_back(u);
        }
    }
}

然后求入度，为拓扑做准备

for(int i=1; i<=n; ++i)
{
    if(V[i].size())
    {
        int sz=V[i].size();
        for(int j=0; j<sz; ++j)
        {
            du[V[i][j]]++;
        }
    }
}

最后是最关键的拓扑环节，答案保存在 res1 中：

q2.push(1); int cur=0;
while(!q2.empty())
{
    int u=q2.front(); q2.pop();
    int sz=V[u].size();
    cur-=du[u];						//关键步骤，意为“恢复所有到达v点的边”
    for(int j=0; j<sz; ++j)
    {
        int v=V[u][j];
        du[v]--;
        if(du[v]==0) q2.push(v);
        cur++;						//关键步骤，意为“撤掉所有由v出发的边”
    }
    if(u!=n) res1=min(res1,cur);	//关键步骤，更新答案
}

下面奉上完整代码：（话说这么一大坨代码划着好麻烦啊，有没有什么好办法呢？）

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;

const int N=2010, M=60010, INF=1e9+7;

class Node
{
public:
    int u, d;
    Node(int u=0, int d=0):u(u),d(d) {};
    bool operator < (const Node & t) const
    {
        return d>t.d;
    }
};

int n, m;
int d[N], du[N], dis[N];
priority_queue<Node> Q;
queue<int> q2;
vector<int> V[N];

class Edge
{
public:
    int to, next, w;
    Edge(int to=0, int next=0, int w=0):to(to),next(next),w(w) {};
    static int h[N], hn;
    static void add(int,int,int);
}e[M<<1];
int Edge::hn, Edge::h[N];
void Edge::add(int u, int v, int w)
{
    e[++Edge::hn]=Edge(v,Edge::h[u],w);
    Edge::h[u]=Edge::hn;
}

void dijkstra(int s)
{
    while(!Q.empty()) Q.pop();
    for(int i=0; i<=n; ++i) d[i]=INF;
    d[s]=0; Q.push(Node(s,0));

    while(!Q.empty())
    {
        Node tmp=Q.top(); Q.pop();
        if(tmp.d!=d[tmp.u]) continue;
        int u=tmp.u;
//        printf("u=%d\n", u);
        for(int p=Edge::h[u]; p; p=e[p].next)
        {
            int v=e[p].to;
            if(d[v]>d[u]+e[p].w)
            {
                d[v]=d[u]+e[p].w;
                Q.push(Node(v,d[v]));
            }
        }
    }
}

int col[N];

void solve()
{
    for(int i=1; i<=n; ++i)
    {
        du[i]=0;
        col[i]=0;
        V[i].clear();
        dis[i]=INF;
        Edge::h[i]=0;
    }
    while(!q2.empty()) q2.pop();
    Edge::hn=0;
    int res1=INF, res2=INF;
    for(int i=1, u, v, w; i<=m; ++i)
    {
        scanf("%d%d%d", &u, &v, &w);
        Edge::add(u,v,w);
        Edge::add(v,u,w);
    }
    dijkstra(1);

    q2.push(n);
    while(!q2.empty())
    {
        int u=q2.front(); q2.pop();
//        printf("u=%d\n", u);
        for(int p=Edge::h[u]; p; p=e[p].next)
        {
            int v=e[p].to;
//            printf("  v=%d\n", v);
            if(d[u]==d[v]+e[p].w)
            {
                if(col[v]==0)
                {
                    q2.push(v);
                    col[v]=1;
                }
                V[v].push_back(u);
            }
        }
    }

    for(int i=1; i<=n; ++i)
    {
//        printf("i=%d\n", i);
        if(V[i].size())
        {
//            printf("u=%d : ", i);
            int sz=V[i].size();
            for(int j=0; j<sz; ++j)
            {
                du[V[i][j]]++;
//                printf(" %d", V[i][j]);
            }
//            puts("");
        }
    }
//    for(int i=1; i<=n; ++i) printf("du[%d]=%d\n", i, du[i]);
    dis[1]=0; q2.push(1); int cur=0;
    while(!q2.empty())
    {
        int u=q2.front(); q2.pop();
        int sz=V[u].size(); cur-=du[u];
        for(int j=0; j<sz; ++j)
        {
            int v=V[u][j];
            du[v]--;
            if(du[v]==0)
            {
                q2.push(v);
            }
            cur++;
            dis[v]=min(dis[v],dis[u]+1);
        }
//        printf("cur=%d\n", cur);
        if(u!=n) res1=min(res1,cur);
    }
    res2=m-dis[n];
    printf("%d %d\n", res1, res2);
}

int main()
{
    while(~scanf("%d%d", &n, &m)) solve();
    return 0;
}

B.搬寝室[HDU - 1421]

给 n 个数，要求从中选出 2*k 个数两两配对，每对数的代价为差的平方，求最小的代价和。（如 5 和 3 配对，代价为 (5-3)2=9 ） 2<=2*k<=n<=2000, 每个数为小于 215 的正整数

排序后，相邻地取数代价最小。考虑dp, f[i][j]表示前 i 个数中取了 j 对数的最小代价和，那么
f[i][j]=min(f[i−1][j],f[i−2][j−1]+(a[i]−a[i−1])2)f[i][j]=min(f[i-1][j],f[i-2][j-1]+(a[i]-a[i-1])^2)f[i][j]=min(f[i−1][j],f[i−2][j−1]+(a[i]−a[i−1])2)
f[i][j] 如果是 2000*2000 的数组的话会MLE，因此我改成了 3*2000。
还有，此题多组数据。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

typedef long long LL;
const int N=2010;
const LL INF=(1ll<<30)*2010;

int n, k;
int a[N];
LL f[3][N];

int main()
{
    while(~scanf("%d%d", &n, &k))
    {
        for(int i=1; i<=n; ++i)
        {
            scanf("%d", a+i);
        }
        sort(a+1,a+n+1);
        for(int i=0; i<3; ++i) for(int j=1; j<=n; ++j) f[i][j]=INF;
        int t=0;
        for(int i=2, o, p, q; i<=n; ++i)
        {
            o=i%3; p=(i-1)%3; q=(i-2)%3;
            for(int j=1; j+j<=i; ++j)
            {
                f[o][j]=min(f[p][j],f[q][j-1]+(a[i]-a[i-1])*1ll*(a[i]-a[i-1]));
            }
        }
        printf("%lld\n", f[n%3][k]);
    }
    return 0;
}

C.Doing Homework again[HDU - 1789]

现有 n 份作业，每份作业需 1 单位时间完成，第 i 份作业截止时间 ti，若截止后才完成，则扣去 ai 分，求最少扣去多少分。 n<=1000

扣分最少即得分最多呗。
可以看到，每份作业若是在截止日期后才做，那大可放在最后做。
首先按 ti 排序，然后按时间顺序做作业，若是当前日期 cur 大于当前作业日期 ti ,那么用这项作业把之前做了的作业中分值最少的那个替换掉（当然，前提是之前分值最少的那个的分值要小于现在这个的分值），这个操作可以用优先队列实现。因此复杂度 nlogn。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;

const int N=1010;

class Data
{
public:
    int t, a;
    static bool cmp(Data&x, Data&y)
    {
        return x.t==y.t?x.a>y.a:x.t<y.t;
    }
}d[N];

int n;
priority_queue<int> Q;

void solve()
{
    int sum=0, cnt=0;
    scanf("%d", &n);
    for(int i=1; i<=n; ++i)
    {
        scanf("%d", &d[i].t);
    }
    for(int i=1; i<=n; ++i)
    {
        scanf("%d", &d[i].a);
        sum+=d[i].a;
    }
    sort(d+1,d+n+1,Data::cmp);
    while(!Q.empty()) Q.pop();
    int day=0;
    for(int i=1; i<=n; ++i)
    {
        if(d[i].t>day)
        {
            Q.push(-d[i].a);
            day++;
            cnt+=d[i].a;
        }else if(!Q.empty() && -Q.top()<d[i].a)
        {
            cnt+=Q.top(); Q.pop();
            Q.push(-d[i].a); cnt+=d[i].a;
        }
    }
    printf("%d\n", sum-cnt);
}

int main()
{
    int T; cin>>T;
    while(T--) solve();
    return 0;
}

D.Almost Regular Bracket Sequence[CodeForces - 1095E]

有一个仅包含 ‘(’ 和 ‘)’ 的括号序列s。 如果括号序列的左右括号可以匹配，则是合法的，否则就是不合法的。（比如"()()“和”(())“是合法的；”)(“和”())"是不合法的）。 现在你只能改变某一个位置的括号（左括号变右括号或者右括号变左括号），请问有几个可以选择的位置。 1<=n<=106，n 为 s 长度

*1900 难度

对于这种括号匹配问题，一个套路就是以 ‘(’ 为 1，以 ‘)’ 为 -1，进行前缀和，此题也不例外。
求前缀和 sum 后，若 sum[n]=2或-2，才有可选择的位置。
若 sum[n]=2，则缺少一个 ‘)’ 。就从右到左寻找第一个 sum[i]=1 的位置，再从 i 向右找第一个 sum[j]=2 的位置，那么在 [j,n] 内 ‘(’ 的个数就是答案。
若 sum[n]=-2，对称做即可。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;

const int N=1e6+10;
int n;
char s[N], t[N];
int a[N];

int main()
{
    scanf("%d%s", &n, t+1);
    for(int i=1; i<=n; ++i)
    {
        if(t[i]=='(') a[i]=a[i-1]+1;
        else a[i]=a[i-1]-1;
    }
    if(a[n]==2)
    {
        for(int i=1; i<=n; ++i)
        {
            s[i]=t[i];
//            printf("%d ", a[i]);
        }
    }
    if(a[n]==-2)
    {
        for(int i=1; i<=n; ++i)
        {
            if(t[n-i+1]=='(') s[i]=')';
            else s[i]='(';
            if(s[i]=='(') a[i]=a[i-1]+1;
            else a[i]=a[i-1]-1;
//            printf("%d ", a[i]);
        }
    }
    int res=0;
    if(a[n]==2)
    {
        int w=0; bool ok=true;
        for(int i=n; i>=1; --i)
        {
            if(a[i]<0)
            {
                ok=false;
                break;
            }
            if(a[i]==1&&w==0) w=i;
        }
        if(ok)
        {
            for(int i=w+1; i<=n; ++i)
            {
                if(s[i]=='(') res++;
            }
        }
    }
    printf("%d\n", res);
    return 0;
}

E.Rectangle Painting 1[CodeForces - 1098D]

给一个 n*n 的网格，每个格子用 ‘#’ 或 ‘.’ 代表，你每次可以选一个 h*w 的矩形将其全涂成 ‘.’ ，代价是 max(h,w)，求将全部 ‘#’ 涂成 ‘.’ 需要的最小代价是多少。 1<=n<=50

*2300难度

易知，若一矩形 H*W (H>W) 的最大代价是H。若想减少代价，必需有某一列无 ‘#’。
考虑dp。 f[x1][x2][y1][y2] 是将 x∈[x1,x2],y∈[y1,y2] 内全变为 ‘.’ 需要的最小代价。
若 x2-x1>=y2-y1，则
f[x1][x2][y1][y2]=min(x2−x1+1,f[x1][i−1][y1][y2]+f[i+1][x2][y1][y2])，第i列无′#′f[x1][x2][y1][y2]=min(x2-x1+1,f[x1][i-1][y1][y2]+f[i+1][x2][y1][y2])，第 i 列无 '\#' f[x1][x2][y1][y2]=min(x2−x1+1,f[x1][i−1][y1][y2]+f[i+1][x2][y1][y2])，第i列无′#′
若 x2-x1<=y2-y1，同理。
至于判断是否全为 ‘.’，预处理前缀和即可。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
 
const int N=50;
 
int n, sig;
char s[N+10];
int a[N+10][N+10], sum[N+10][N+10];
int f[N+2][N+2][N+2][N+2];
 
int cnt(int x, int y, int xx, int yy)
{
    return sum[xx][y]-sum[x-1][y]-sum[xx][yy-1]+sum[x-1][yy-1];
}
 
int main()
{
    cin>>n;
    for(int i=1; i<=n; ++i)
    {
        scanf("%s", s+1);
        for(int j=1; j<=n; ++j)
        {
            if(s[j]=='#') a[i][j]=1;
        }
    }
 
    for(int i=1; i<=n; ++i)
    {
        for(int j=1; j<=n; ++j)
        {
            sum[i][j]=sum[i][j-1]+sum[i-1][j]-sum[i-1][j-1]+a[i][j];
        }
    }
    for(int x1=1; x1<=n; ++x1)
    {
        for(int x2=x1; x2>=1; --x2)
        {
            for(int y1=1; y1<=n; ++y1)
            {
                for(int y2=y1; y2>=1; --y2)
                {
                    f[x1][x2][y1][y2]=max(x1-x2,y1-y2)+1;
                    if(x1-x2>=y1-y2)
                    {
                        for(int i=x2; i<=x1; ++i)
                        {
                            if(cnt(i,y1,i,y2)==0)
                            {
                                f[x1][x2][y1][y2]=min(f[x1][x2][y1][y2],f[i-1][x2][y1][y2]+f[x1][i+1][y1][y2]);
                            }
                        }
                    }
                    if(x1-x2<=y1-y2)
                    {
                        for(int j=y2; j<=y1; ++j)
                        {
                            if(cnt(x2,j,x1,j)==0)
                            {
                                f[x1][x2][y1][y2]=min(f[x1][x2][y1][y2],f[x1][x2][j-1][y2]+f[x1][x2][y1][j+1]);
                            }
                        }
                    }
                }
            }
        }
    }
    printf("%d\n", f[n][1][n][1]);
    return 0;
}

F.Maximum Value[CodeForces - 485D]

给出一个数列 a 由 n 个整数组成，求 ai%aj 的最大值（ai>aj）。 1<=n<=2*105, 1<=ai<=106

*2100难度

若 % ai 的最大值，只需对于所有 x=ai*k ,(k>=2,k*ai<=2*106)，对每次数列中小于 x 的最大值 aj 求 aj%ai 即可。
预处理后，aj 可以 O(1) 得到。由于 1+1/2+1/3+1/4+…+1/n≈log2(n+1)+C，此题复杂度为 O(MlogM)，M=2*106，也可以取 M 为 a 中的最大值。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
 
const int N=1e6;
 
int n;
int a[N*2+10], pre[N*2+10];
 
int main()
{
    scanf("%d", &n);
    for(int i=1, x; i<=n; ++i)
    {
        scanf("%d", &x);
        a[x]=1;
    }
    for(int i=2; i<=N*2; ++i)
    {
        if(a[i-1]) pre[i]=i-1;
        else pre[i]=pre[i-1];
    }
    int res=0;
    for(int i=2; i<=N; ++i)
    {
        if(a[i]==0) continue;
        for(int j=i+i; j<=N*2; j+=i)
        {
            res=max(res,pre[j]%i);
        }
    }
    printf("%d\n", res);
    return 0;
}

G.Mister B and PR Shifts[CodeForces - 820D]

*1900难度

前面说过不想写题解了。
就放一个别人的题解吧。
https://www.cnblogs.com/TnT2333333/p/7091392.html

.
.
.

感谢客官看到这里。有什么问题欢迎指出！_(:3」∠❀)_

太阳高度角/方位角计算公式
MY_MichealYang的博客
05-01 8万+
太阳高度角/方位角计算公式本文不在此介绍太阳高度角、方位角是什么，相关概念请移步Wikipedia。鉴于很多相关专业人员需要计算太阳高度角、方位角，而网上介绍的公式多数或是不正确，或是杂乱无章。作者经查阅相关理论和教程，在此整理了下太阳高度角、方位角等的计算公式，并根据此公式做出了相关产品，通过了检验。如有错误，请各位指正。太阳高度角/方位角在线计算太阳高度角计算公式一般情况下，地理纬度ϕ\phi是
php 真太阳时间修正,全国真太阳时对照表
weixin_31865183的博客
03-31 3392
术数占测，需要以真太阳时为标准。尤其是测算八字命理及择日动用更要严格谨慎，所谓“失之毫厘谬以千里”，大家不可不察。现在把全国各地真太阳时表发布一下，供大家参考。什么是真太阳时？如何确定真太阳时？时辰究竟应该按照什么标准确定呢? 唯一的标准就是太阳相对于地球的视角，即天文学上所谓的真太阳时。凡定生时，必须按照其出生地点，推算出当地的平太阳时，再根据平太阳时推算出真太阳时为准，不能直接采用北京标准时间...
Php真太阳时计算公式,李顺祥：真太阳时的计算与应用
weixin_39616565的博客
03-18 6319
真太阳时的计算与应用李顺祥对于已经完全掌握了真太阳时知识的易友来说，就不必再学。这一文的内容是为了照顾部分对真太阳时不太明白的易友而附加的。不过，后面所列出的真太阳与平太阳时之间的时差数据还是人人都可以查用的。用北京时间排四柱的方法早已被命学界否定，只有那些不懂得五行时间与行政时间之区别的人仍然在使用北京时间排四柱。目前，大多数命理预测师都采用地方时即太阳时排四柱。但是，太阳时又有平太阳时(即平均...
python代码计算太阳高度角和太阳方位角
mumu__fairy的博客
04-12 4585
使用python代码计算某一地点某一时间的太阳高度角和太阳方位角
【51Nod 1531】 树上的博弈（树形DP）
white514的博客
10-12 1068
树形DP，状态的表示十分巧妙。
CodeForces Hello2020 D. New Year and Conference 题解（中文版）
white514的博客
01-07 1023
Hello2020 D. New Year and Conference 的中文题解（当然不是无脑翻译） 还有一个看不太懂的概率程序
【UVa1617】Laptop 笔记本（贪心）
white514的博客
10-22 737
贪心，自己还是想不到
【51Nod1588】幸运树（树形DP）
white514的博客
10-15 674
用树形DP计数，这也许是一个套路，也许我还没掌握住。
【洛谷2458】【SDOI2006】保安站岗（树形DP）
white514的博客
10-19 660
树形DP，一个经典套路
【洛谷1272】重建道路（树形DP）
white514的博客
10-19 644
树形DP + 背包，思路较好想，但细节难处理。
【UVa12265】Selling Land 贩卖土地
white514的博客
10-02 612
题目描述As you may know, the country of Absurdistan is full of abnormalities. For example, the whole country can be divided into unit squares that are either grass or swamp. Also, the country is famous fo
【CodeForces 767C】Garland （树形DP）
white514的博客
10-18 492
一道比较简单的树形DP，但有些细节很难想到，容易被 hack
【51Nod1673】树有几多愁（虚树+树形DP+状压DP）
white514的博客
10-18 477
虚树+树形DP+状压DP 的好题啊！！！
【luogu3621】【APIO2007】风铃（树形DP）
white514的博客
10-18 459
一道细节较多的树形DP
【BZOJ2287】【POJ Challenge】消失之物（DP，背包）
white514的博客
10-15 448
运用补集思想的巧妙DP（一道思路题）
[BZOJ2426][HAOI2010] 工厂选址 (神奇的贪心)
white514的博客
10-07 436
这道题思路很强，题面比较坑 旧厂必须只被供给b吨煤（不能多也不能少），其余煤必须都给新厂。 枚举所有新厂，把所有的煤都给新厂，再求出所有煤矿的（旧厂运费-新厂运费）值，从小到大排序，按顺序把旧厂该得的煤拿回来。这个思路很强。  #include #define rep(i,j,k) for(int i=(int)j; i<=(int)k; ++i) using namespace s
【BZOJ3307】雨天的尾巴（树链剖分+树上差分+线段树）
white514的博客
10-12 435
树链剖分+树上差分+线段树 的神题，膜拜膜拜
洛谷 P1134 阶乘问题
white514的博客
02-04 427
数论精选题
算法与数据结构之Floyd算法
最新发布
weixin_73953650的博客
06-20 520
超详细的Floyd算法教程，一看就懂！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值