HGOI20190707 题解

Problem A 钢铁侠的诞生

现在有$n$个数字$a_i \leq 10^9 $，然后取出$m$个数字，保证合法。

从小到大输出剩余的$n-m$个数字。

对于100%的数据$m\leq n \leq 3\times 10^5$

Sol : 直接map映射然后用iterator来遍历整个map输出答案即可。

复杂度大概是$O(n log_2 n)$

# pragma GCC optimize(2)
# include<bits/stdc++.h>
using namespace std;
int n,m;
map<int,int>mp;
int main()
{scanf("%d%d",&n,&m);for (int i=1;i<=n;i++) {int t; scanf("%d",&t);mp[t]++;}for (int i=1;i<=m;i++) {int t; scanf("%d",&t);mp[t]--;}map<int,int>::iterator it;for (it=mp.begin();it!=mp.end();++it) {pair<int,int>p=*it;for (int j=1;j<=p.second;j++) printf("%d ",p.first);}return 0;
}

a.cpp

Problem B 钢铁侠的逃离

设函数$f(x) = $x的二进制中"1"的个数。求 $\sum\limits_{i=1}^n f(B+i\times A)$ 的值。

对于100%的数据$A\leq 10^4 ,B \leq 10^{16} n\leq 10^{12} $

Sol : 对于每一个二进制位分别考虑，我们想法是对于二进制数第$k$位 $ B+A $和 $ B+(2^k+1)A $是相同的。

证明的话直接可以把两个数同时减去一个A，然后就变成了$B$和$B+(2^k)A$第$k$位的关系。

左式的$2^k A$相当于把A向左移k位，这个时候第k位一定是B的k位的数+0 = B的k位的数。那么就不会发生变化。

所以我们只需要考虑一个循环节$B+A ... B+2^k A$中1的个数即可。

对于每个循环节，显然（也可以通过打表发现）每一位连续是1连续是0的可能比较大。所以我们考虑对于连续的1和连续的0一起处理。

设$f(a,b,k,r) = \sum\limits_{i=0} ^ {r} b+a\times i 中第k位1的个数 $

考虑如何算$f(a,b,k,r)$ . 首先我们需要在每一个01块内用O(1)的时间完成跳跃。

于是考虑什么时候是01的分界点。由于进位的问题所以每一个01块分界点一定是以$2^k$一个循环的，并且是$2^k$的倍数。

考虑一个位置 b 我们什么时候才能跳出这个块呢？比该点更加靠右的$2^k$倍数的点可以轻易算出 $2^k \times (\left \lfloor \frac{b}{2^k} \right \rfloor\times +1 ) $ 就是下一个01分界点的坐标。

注意到01分界点事实上已经完成了进位即完成了01转换。

所以如果要跳到严格的下一个01分界点的右侧，我们需要跳跃$c= \frac{2^k \times (\left \lfloor \frac{b}{2^k} \right \rfloor +1 ) -1 }{a}+1$步

所以，对于$f(a,b,k,r)$的求法已经非常明确了：

$f(a,b,k,r) = \left\{\begin{matrix} b\ and \ 2^k = 0 \left\{\begin{matrix} 0 & r-c<0\\ \ \ \ f(a,b+c\times a,k,r-c)\ \ & r \geq c \end{matrix}\right.\\ b\ and \ 2^k = 1 \left\{\begin{matrix} r+1 & r-c<0\\ c+f(a,b+c\times a,k,r-c)& r \geq c \end{matrix}\right.\\ \end{matrix}\right.$

由于是从0开始的，所以n必须等于n-1 ，当前是从b+a开始的，所以是b=b+a

答案就是$ans = \sum\limits_{i=0}^{bit\_num(a+nb)} f(a,b,i,2^{i+1}-1)\times \left \lfloor \frac{n}{2^{i+1}} \right \rfloor+ f(a,b+\left \lfloor \frac{n}{2^{i+1}} \right \rfloor \times 2^{i+1} \times a,i,n \mod 2^{i+1})$

# include <bits/stdc++.h>
# define int long long
using namespace std;
int fun(int a,int b,int k,int r){int d=b/(1ll<<k),c=((1ll<<k)*(d+1)-1-b)/a+1;if(d&1) return c>r?r+1:c+fun(a,b+c*a,k,r-c);else return c>r?0:fun(a,b+c*a,k,r-c);
}
signed main()
{int T; scanf("%d",&T);while (T--) {int a,b,n;scanf("%lld%lld%lld",&a,&b,&n);int ans=0; b+=a; n--; for (int i=0;i<=54;i++) {int c=n/(1ll<<i+1);ans+=fun(a,b,i,(1ll<<i+1)-1)*c+fun(a,b+(1ll<<i+1)*c*a,i,n-c*(1ll<<i+1));}printf("%lld\n",ans);  }return 0;
}

b.cpp

Problem C 钢铁侠的复仇

设一个$N\times M$的矩阵，设$A_{i,j}$表示点$(i,j)$被攻克的难度而$B_{i,j}$ 表示点$(i,j)$被攻克的时间。

从$(i_1,j_1)$点转移到$(i_2,j_2)$点需要花费 $|i_1 - i_2|+|j_1-j_2|$ 的代价。

一条合法的攻克路径满足：经过路径上的所有点不重复而且不能经过$A_{i,j} = B_{i,j} = 0$的点。

输出沿着最长时间路径访问的时间。

对于100%的数据$ n,m \leq 10^3 $

Sol ：本题是一个DP题目。

设$f_{i,j}$表示经过到点$(i,j)$结尾的路径的最大时间。

显然需要按照$A_{i,j}$值递增的顺序依次更新每个点。

转移方程就是$f_{i,j} = \max\limits_{k=1,w=1} ^ {k\leq n , w\leq m} [(A_{k,w} < A_{i,j}) f_{k,w}+|i-k|+|j-w|] + b_{i,j} $

复杂度 $O(n^2 m^2)$ get 30pts

# pragma GCC optimize(2)
# include <bits/stdc++.h>
# define int long long
using namespace std;
const int N=1e3+10;
struct rec{int x,y,d;
};
int n,m;
struct cmp {bool operator () (rec a,rec b) {return a.d>b.d;}
};
int a[N][N],b[N][N],f[N][N];
priority_queue<rec,vector<rec>,cmp>q;
signed main()
{scanf("%d%d",&n,&m);for (int i=1;i<=n;i++)for (int j=1;j<=m;j++)scanf("%d",&a[i][j]),q.push((rec){i,j,a[i][j]});for (int i=1;i<=n;i++)for (int j=1;j<=m;j++)scanf("%d",&b[i][j]);int ans=0;while (!q.empty()) {rec u=q.top();q.pop();if (a[u.x][u.y]==0&&b[u.x][u.y]==0) continue;f[u.x][u.y]=b[u.x][u.y];for (int i=1;i<=n;i++)for (int j=1;j<=m;j++)if (a[i][j]!=0&&a[i][j]<a[u.x][u.y]&&!(i==u.x&&j==u.y)) f[u.x][u.y]=max(f[u.x][u.y],f[i][j]+b[u.x][u.y]+abs(u.x-i)+abs(u.y-j));ans=max(ans,f[u.x][u.y]);        }          printf("%d\n",ans);return 0;
}

c_30pts.cpp

考虑优化这个转移。

显然绝对值符号可以被拆，例如$(x,y)$在$(i,j)$左上角的时候($i \geq x , j \geq y$)时有$f_{i,j} +| i - x | +| j - y | = f_{i,j}+i+j - x - y$

还有其他的三种情况不再赘述。

按照@hjc20032003的方法，可以先按$A_{i,j}$的大小把元素分成若干块(每一块里面的所有元素$A_{i,j}$值都相同)。

显然第k块中的$f_{i,j}$是k-1那一块的$f_{i,j}$转移而来。

我们先考虑$(x,y)$在$(i,j)$左上角的情况。

可以把相邻两块和并（由于当前行一定是从前一个可能的$A_{i,j}$转移而来的），并按照x坐标排序，然后从先到后依次扫，如果当前的元素$(x,y)$之前在前一个块(k-1)中那么插入到线段树第y号位子中。

如果当前元素在当前块$k-1$中那么利用当前线段树的元素查询在他左上角元素的信息来更新当前位置的f值$f_{x,y}$。

由于插入线段树的元素的$x$的坐标都是小于当前的元素的$x$坐标的，并且我们可以通过查询当前元素$y$之前区间信息而控制转移来源的点是在当前点的左上方的。

当然，由于可能从4个不同的方向转移，类似的操作要做4次(x轴翻转,y轴翻转,o点翻转,不翻转) 。具体可以参考[Violet]天使玩偶/SJY摆棋子的处理方法。

复杂度大概是$O(4 \times nm log_2 nm)$

#include<bits/stdc++.h>
#define GX(x,y) x=max(x,y)
#define ls(x) x<<1
#define rs(x) x<<1|1
#define A first
#define B second
#define mk make_pair
#define pb push_back
#define int long long
#define REP(i,s,t) for(int i=s;i<=t;i++)
using namespace std;
const int maxn=1005,inf=0x3fffffffffffffff;
typedef pair<int,int> pii;
vector<pii> vec[maxn*maxn];
int n,m,dis[maxn*maxn],a[maxn][maxn],b[maxn][maxn],f[maxn][maxn];
struct rec{int x,y; bool w;}q[maxn*maxn];
bool tag[maxn<<2];
int maxx[maxn<<2];
void push_down(int p){if(tag[p]) tag[ls(p)]=tag[rs(p)]=true,maxx[ls(p)]=maxx[rs(p)]=-inf,tag[p]=false;
}
void _modify(int p,int l,int r,int tar,int val){if(l==r){GX(maxx[p],val); return;}int m=l+r>>1;push_down(p);if(tar<=m) _modify(ls(p),l,m,tar,val);else _modify(rs(p),m+1,r,tar,val);maxx[p]=max(maxx[ls(p)],maxx[rs(p)]);
}
void modify(int tar,int val){_modify(1,1,m,tar,val);}
int _query(int p,int l,int r,int nl,int nr){if(nl<=l&&r<=nr) return maxx[p];int m=l+r>>1,ret=-inf;push_down(p);if(nl<=m) GX(ret,_query(ls(p),l,m,nl,nr));if(m<nr) GX(ret,_query(rs(p),m+1,r,nl,nr));return ret;
}
int query(int nl,int nr){return _query(1,1,m,nl,nr);}
bool cmp1(rec a,rec b){if(a.x!=b.x) return a.x<b.x;return a.y<b.y;
}
signed main(){
//  freopen("c.in","r",stdin);
//  freopen("c.out","w",stdout);scanf("%lld%lld",&n,&m);int dis_cnt=0;REP(i,1,n) REP(j,1,m) scanf("%lld",&a[i][j]);REP(i,1,n) REP(j,1,m) scanf("%lld",&b[i][j]);REP(i,1,n) REP(j,1,m) if(a[i][j]) dis[++dis_cnt]=a[i][j];sort(dis+1,dis+1+dis_cnt);int cnt=unique(dis+1,dis+1+dis_cnt)-dis-1;REP(i,1,n) REP(j,1,m) if(a[i][j])a[i][j]=lower_bound(dis+1,dis+cnt+1,a[i][j])-dis,vec[a[i][j]].pb(mk(i,j));for(int i=0;i<vec[1].size();i++) f[vec[1][i].A][vec[1][i].B]=b[vec[1][i].A][vec[1][i].B];REP(c,2,cnt){int pt=0;for(int i=0;i<vec[c-1].size();i++) q[++pt]=(rec){vec[c-1][i].A,vec[c-1][i].B,0};for(int i=0;i<vec[c].size();i++) q[++pt]=(rec){vec[c][i].A,vec[c][i].B,1};sort(q+1,q+1+pt,cmp1);tag[1]=true; maxx[1]=-inf;REP(i,1,pt)if(!q[i].w) modify(q[i].y,f[q[i].x][q[i].y]-q[i].x-q[i].y);else GX(f[q[i].x][q[i].y],query(1,q[i].y)+b[q[i].x][q[i].y]+q[i].x+q[i].y);tag[1]=true; maxx[1]=-inf;for(int i=pt;i;i--) if(!q[i].w) modify(q[i].y,f[q[i].x][q[i].y]+q[i].x-q[i].y);else GX(f[q[i].x][q[i].y],query(1,q[i].y)+b[q[i].x][q[i].y]-q[i].x+q[i].y);tag[1]=true; maxx[1]=-inf;REP(i,1,pt) if(!q[i].w) modify(q[i].y,f[q[i].x][q[i].y]-q[i].x+q[i].y);else GX(f[q[i].x][q[i].y],query(q[i].y,m)+b[q[i].x][q[i].y]+q[i].x-q[i].y);tag[1]=true; maxx[1]=-inf;for(int i=pt;i;i--)if(!q[i].w) modify(q[i].y,f[q[i].x][q[i].y]+q[i].x+q[i].y);else GX(f[q[i].x][q[i].y],query(q[i].y,m)+b[q[i].x][q[i].y]-q[i].x-q[i].y);}int ans=0;REP(i,1,n) REP(j,1,m) GX(ans,f[i][j]);cout<<ans<<endl;return 0;
}

c.cpp

但是，这样处理的常数非常大，由于绝对值符号的性质，按照上述四种转移方法只可能有一种转移方法是正确的。

由于绝对值的性质有$|i-x| \geq i-x$ 所以有

$ f_{i,j} + |i-x| + |j - y| = max\{ f_{i,j} + (i - x) + (j - y), f_{i,j} + (i - x) + (y - j), f_{i,j} + (x - i) + (j - y), f_{i,j} + (x - i) + (y - j)\} $ 成立。

所以转移的时候可以直接无视$i,x,j,y$的大小关系，一并转移即可。

转移方程是 $ f_{x,y}= max\{ -x - y + max(f_{i,j} + i + j), -x + y + max(f_{i,j} + i - j), x - y + max(f_{i,j} - i + j), x + y + max(f_{i,j} - i - j) ) $

其中$max(f_{i,j} + i + j) ... $是全局变量在每次转移完成后维护即可。

还要注意初始值不能加上坐标，即非0的最小的$A_{i,j}$所对应的$f_{i,j}$一开始从自己转移不能加上横纵坐标!!!

# include <bits/stdc++.h>
# define int long long
# define inf (0x3f3f3f3f3f3f3f3f)
using namespace std;
const int N=1e3+10;
int f[N][N],b[N][N];
vector<pair<int,int> >v[N*N];
pair<int,int>t[N*N];
int mx1,mx2,mx3,mx4,ans,mint;
int n,m;
int Max(int a,int b,int c,int d) {if (b>a) a=b;if (c>a) a=c;if (d>a) a=d;return a;
}
void work(int r)
{if (v[r].size()==0) return;int cnt=0;for (int i=0;i<v[r].size();i++) t[++cnt]=v[r][i];int mxa=0,mxb=0,mxc=0,mxd=0;for (int i=1;i<=cnt;i++) {int x=t[i].first,y=t[i].second;if (r==0) continue;if (r!=mint) f[x][y]=Max(-x-y+mx1,-x+y+mx2,x-y+mx3,x+y+mx4)+b[x][y];else f[x][y]=b[x][y];ans=max(ans,f[x][y]);mxa=max(mxa,f[x][y]+x+y); mxb=max(mxb,f[x][y]+x-y);mxc=max(mxc,f[x][y]-x+y); mxd=max(mxd,f[x][y]-x-y);}mx1=max(mx1,mxa); mx2=max(mx2,mxb);mx3=max(mx3,mxc); mx4=max(mx4,mxd);
}
signed main()
{scanf("%lld%lld",&n,&m);mint=inf;for (int i=1;i<=n;i++)for (int j=1;j<=m;j++) {int t; scanf("%lld",&t);if (t!=0) mint=min(mint,t);v[t].push_back(make_pair(i,j));     }for (int i=1;i<=n;i++)for (int j=1;j<=m;j++) scanf("%lld",&b[i][j]);for (int a=0;a<=1000000;a++) work(a);  printf("%lld\n",ans);  return 0;
}

c.cpp

转载于:https://www.cnblogs.com/ljc20020730/p/11146210.html

HGOI20190707 题解相关推荐

[JS][dfs]题解 | #迷宫问题#
题解 | #迷宫问题# 题目链接迷宫问题题目描述定义一个二维数组 N*M ,如 5 × 5 数组下所示: int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 1, 1 ...
[JS][dp]题解 | #打家劫舍(一)#
题解 | #打家劫舍(一)# 题目链接打家劫舍(一) 题目描述描述你是一个经验丰富的小偷,准备偷沿街的一排房间,每个房间都存有一定的现金,为了防止被发现,你不能偷相邻的两家,即,如果偷了第一家, ...
[JS]题解 | #魔法数字#
题解 | #魔法数字# 题目链接魔法数字题目描述牛妹给牛牛写了一个数字n,然后又给自己写了一个数字m,她希望牛牛能执行最少的操作将他的数字转化成自己的. 操作共有三种,如下: 在当前数字的基础上 ...
[JS]题解 | #岛屿数量#
题解 | #岛屿数量# 题目链接岛屿数量题目描述时间限制:1秒空间限制:256M 描述给一个01矩阵,1代表是陆地,0代表海洋, 如果两个1相邻,那么这两个1属于同一个岛.我们只考虑上下左右 ...
[JS] 题解：提取不重复的整数
题解:提取不重复的整数 https://www.nowcoder.com/practice/253986e66d114d378ae8de2e6c4577c1 时间限制:1秒空间限制:32M 描述输 ...
洛谷-题解 P2672 【推销员】
独门思路!链表加优先队列! 这题一望,贪心是跑不掉了,但是我贪心并不好,所以想到了一个复杂一些但思路更保稳的做法思路: 1 因为是离线操作,所以我们可以倒着求,先求x=n的情况,因为那样直接就知道了 ...
[洛谷1383]高级打字机题解
题解这道题一看就珂以用主席树啊这是一道神奇的题目,那么我们先敲一个主席树,然后维护一个数组len,表示下一次应该在len + 1插入, 之后对于T操作,在上一个版本的len + 1上直接执行插入 ...
luogu P1549 棋盘问题（2）题解
luogu P1549 棋盘问题(2) 题解题目描述在$N * N$的棋盘上$(1≤N≤10)$,填入$1,2,-,N^2$共$N^2$个数,使得任意两个相邻的数之和为素数. 例如 ...
【题解搬运】PAT_L1-009 N个数求和
从我原来的博客上搬运.原先blog作废. (伪)水题+1,旨在继续摸清这个blog(囧题目就是求N个数字的和.麻烦的是,这些数字是以有理数"分子/分母"的形式给出的,你输出的和 ...

HGOI20190707 题解

HGOI20190707 题解相关推荐

最新文章

热门文章