Codeforces Round #675 (Div. 2)A-D题解
比赛链接:https://codeforces.com/contest/1422
A题
题意为给定四边形的三条边，让你输出一个整数，与其能够构成一个四边形。
类似三角形的定理，需要满足最小长度的三条边的和需要大于最大的那一条。
这里我选择的构造方式就是用最大的那条边减去另外两条边（和0要取个max）再加1。
#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
int32_t main()
{
IOS;
int t;
cin>>t;
while(t--)
{
ll a,b,c;
cin>>a>>b>>c;
if(a>b) swap(a,b);
if(b>c) swap(b,c);
cout<<max(0ll,c-a-b)+1<<endl;
}
}
B题
简单结论，细节处理。
题意为给定一个n × \times ×n的矩阵，你每次操作可以对其中的某一个数字+1或者-1，问你最少需要进行多少次操作，使得整个矩阵每一列都是对称的，每一行也是对称的。
这里的话先观察，我们以矩阵的中心为原点，水平和竖直建立坐标系，会发现在x和y轴上的点，在矩阵中都只需要和另一个数保持一致，而不在坐标轴上的点，都需要与另外三个数保持一致。
让两个数保持一致的操作次数很简单，就是两个数字差值的绝对值。
四个数字保持一致的话，我们可以采用假设最终的数字的值在哪个范围来得到结论。
假设四个数字从小到大排序是a,b,c,d。我们假设最后构造的值落在c的右边，那么我们完全可以让这个值-1，这样的话a,b,c三个数字都少操作了一次，而d多操作了一次，总操作次数-2，会更优。
同理也可以推得最后构造的值在b的左边也不是最优的。
因此我们最后构造的值就是在b到c的闭区间内，并且操作次数相同。所以直接四个数字和c相减取绝对值加起来就是最少操作次数了。
之后就是实现了。
#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
ll num[107][107];
int32_t main()
{
IOS;
int t;
cin>>t;
while(t--)
{
int n,m;
cin>>n>>m;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++) cin>>num[i][j];
ll ans=0;
for(int i=1;i<=n/2;i++)//除了奇数行的中间行外，所有位置都有对应三个另外的位置要保持相同
{
for(int j=1;j<=m/2;j++)
{
vector<ll>temp;
temp.push_back(num[i][j]);
temp.push_back(num[i][m-j+1]);//同一行的另一个数
temp.push_back(num[n-i+1][j]);//同一列的另一个数
temp.push_back(num[n-i+1][m-j+1]);//关于矩阵中心对称的另一个数
sort(temp.begin(),temp.end());
for(auto &x:temp) ans+=abs(x-temp[2]);
}
if(m&1) ans+=abs(num[i][m/2+1]-num[n-i+1][m/2+1]);//中间列是特殊情况
}
if(n&1)//奇数行的中间那一行额外处理，此时每个位置需要保持相同的数只有另外一个
{
for(int j=1;j<=m/2;j++) ans+=abs(num[n/2+1][j]-num[n/2+1][m-j+1]);
}
cout<<ans<<endl;
}
}
C题
dp
题意为给定一个长度最长为1e5级别的数字，你可以在其中删除长度不为0的连续的某一段数字，把剩下的数字拼接起来构成一个新的数字。
你需要输出所有删除方案得到的数字的和。
算是个比较容易看出来的线性dp，具体转移方程看代码和注释吧。
#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
const ll maxn=1e5+7;
const ll mod=1e9+7;
string s;
struct Node
{
ll data,cas;//data记录值总共为多少，cas为有多少组情况
};
Node dp[maxn][3];//方便理解起见，这里每个下标对应三种状态
//dp[i][0]代表用前i个数字在已经删除了一段区间并且这个区间的最后一个位置是下标i的情况下，构成的所有数值和，以及对应有多少组情况
//dp[i][1]代表用前i个数字在已经删除了一段区间并且这个区间的最后一个位置不是下标i的情况下，构成的所有数值和，以及对应有多少组情况
//dp[i][2]代表用前i个数字未删除区间的情况下，构成的所有数值和，以及对应有多少组情况（这里一直是1）
int32_t main()
{
IOS;
cin>>s;
dp[0][2].cas=1;
for(int i=0;i<s.size();i++)
{
dp[i+1][0].cas=(dp[i][0].cas+dp[i][2].cas)%mod;//删除当前位置，由于只能删除一段连续的区间，因此不能从dp[i][1]转移过来
dp[i+1][0].data=(dp[i][0].data+dp[i][2].data)%mod;
dp[i+1][1].cas=(dp[i][0].cas+dp[i][1].cas)%mod;//保留当前位置，并且之前已经有删除过，因此从dp[i][0]和[1]转移过来
dp[i+1][1].data=((dp[i][0].data+dp[i][1].data)%mod*10%mod+dp[i+1][1].cas*(s[i]-'0')%mod)%mod;
dp[i+1][2].cas=dp[i][2].cas;
dp[i+1][2].data=(dp[i][2].data*10+s[i]-'0')%mod;
}
cout<<(dp[s.size()][0].data+dp[s.size()][1].data)%mod<<endl;
}
D题
思维，结论优化，最短路
题意为在一个二维平面上给定起点和终点的坐标，每次移动你只能朝着上下左右移动1的距离。
但是这个平面上有m个特殊节点，当你的位置与这个节点的横坐标或者纵坐标相同时，你可以不花费任何时间直接到达这个节点的位置。询问从起点到终点最少要移动多少次（不包括瞬移到特殊节点的移动）。
这里很容易想到的，把起点和终点还有m个特殊点当做图的结点，变成最短路问题，其中起点与终点之间的距离是横纵坐标差的绝对值和，而有特殊点作为端点的边，则是横纵坐标差值的较小值作为距离。但是这样构图的话，是一个m+2个结点的完全图，边数量(m+2)2 跑最短路是必然会tle的。
我们注意到起点到m个特殊点的单向边 ，以及起点，m个特殊点到终点的单向边是必须加入到图中的。
但是m个特殊点之间的m2 条特殊边还是可以优化的，并不需要全部加入。
这里要先推一个小结论，对于两个点a[x1,y1],b[x2,y2]，x1<x2,y1<y2，如果有第三个点c[x3,y3]，满足x1<=x3<=x3或者y1<=y2<=y3的话。
由于从a点到b点，必然是从a点先经过x方向（水平）或者y方向（竖直）走到可以直接瞬移到b的位置。而在这个过程中，必然会经过c点的横纵坐标相同的某个点，瞬移到c点再接着原来的路径方向走，所需移动次数是不会产生变化的。也就是说a到b之间的路径，可以由a到c和c到b这两条路径构成。
也就是任意两个特殊点的距离，都可以用x方向上或者y方向上这两个特殊点中间的点的边来表示。利用这个结论对大边不断分割后，最后全部转化为了x方向和y方向上，相邻两个点之间的边。
由此m2 条边就被压缩成了2m-2条边，此时的最短路算法mlogn就可以在时间内跑完了。
#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
const ll maxm=1e5+7;
struct Edge
{
ll to,next,dis;
}edge[maxm<<3];
ll head[maxm],tot;
ll n,m;
void init()
{
for(ll i=0;i<=m+1;i++) head[i]=-1;
tot=0;
}
void add(ll u,ll v,ll w)
{
edge[tot].to=v;
edge[tot].next=head[u];
edge[tot].dis=w;
head[u]=tot++;
}
ll dis[maxm];
struct Node
{
ll pos,val;
Node(ll pos,ll val):pos(pos),val(val){
}
friend bool operator < (Node a,Node b)
{
return a.val>b.val;
}
};
ll Dijstra()
{
for(ll i=0;i<=m+1;i++) dis[i]=llINF;
dis[0]=0;
priority_queue<Node>Q;
Q.push(Node(0,0));
while(Q.size())
{
Node now=Q.top();
Q.pop();
if(now.val>dis[now.pos]) continue;
for(ll i=head[now.pos];i!=-1;i=edge[i].next)
{
ll to=edge[i].to;
if(dis[to]>edge[i].dis+now.val)
{
dis[to]=edge[i].dis+now.val;
Q.push(Node(to,dis[to]));
}
}
}
return dis[m+1];
}
struct Point
{
ll x,y,tar;
}point[maxm];
bool cmp1(Point a,Point b){
return a.x<b.x;}
bool cmp2(Point a,Point b){
return a.y<b.y;}
int32_t main()
{
IOS;
cin>>n>>m;
init();
cin>>point[0].x>>point[0].y>>point[m+1].x>>point[m+1].y;//起点下标0，终点下标m+1
for(ll i=1;i<=m;i++) {
cin>>point[i].x>>point[i].y;point[i].tar=i;}
for(ll i=1;i<=m;i++) add(0,i,min(abs(point[i].x-point[0].x),abs(point[i].y-point[0].y)));//起点到m个特殊点的边加进图中
for(ll i=0;i<=m;i++) add(i,m+1,abs(point[m+1].x-point[i].x)+abs(point[m+1].y-point[i].y));//起点和m个特殊点，与终点的边加进图中
//以上均可以直接设置为单向边
//之后还需要加的就是m个特殊点之间的边了
sort(point+1,point+m+1,cmp1);//按照x从小到大排序后，相邻特殊点之间建立双向边
for(ll i=1;i<m;i++)
{
ll dis=min(abs(point[i].x-point[i+1].x),abs(point[i].y-point[i+1].y));
add(point[i].tar,point[i+1].tar,dis);
add(point[i+1].tar,point[i].tar,dis);
}
sort(point+1,point+m+1,cmp2);//按照y从小到大排序后，相邻特殊点之间建立双向边
for(ll i=1;i<m;i++)
{
ll dis=min(abs(point[i].x-point[i+1].x),abs(point[i].y-point[i+1].y));
add(point[i].tar,point[i+1].tar,dis);
add(point[i+1].tar,point[i].tar,dis);
}
cout<<Dijstra()<<endl;//跑个最短路完事了
}