1.旅行家问题1
**考察：**思维题，贪心
思路：
如果x在左右两边，只需要走单程；如果在中间，就为更短的那边*2+长的那边
代码如下：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5+10;
ll a[N],x,n,ans;
//快读
void rd(long long &x){
char c;
for (x=0,c=getchar();c<48;c=getchar());
for (;c>47;c=getchar()) x=(x<<1)+(x<<3)+(c^48);
}
void solve(){
rd(n),rd(x);
for(int i=1;i<=n;i++) rd(a[i]);
sort(a+1,a+n+1);
if(x<=a[1]) ans=a[n]-x;
else if(x>=a[n]) ans=x-a[1];
else{
int d1=x-a[1],d2=a[n]-x;
if(d1>d2) ans=2*d2+d1;
else ans=2*d1+d2;
}
cout<<ans<<endl;
}
int main(){
int t;
t=1;
while(t--){
solve();
}
return 0;
}
2.字母收集
考察：动态规划
思路：
因为只能往下或往右走，所以每个都只能来自左边或上边。
我们将字符和对应的值进行映射。
走到某个格子时的最大值就为
dp[i][j]=max(dp[i-1][j],dp[i][j-1])+mp[g[i][j]];
目标是：dp[n][m]
代码如下：
//字母收集思路：动态规划
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 510;
int n,m,dp[N][N],ans;
char g[N][N];
unordered_map<char,int> mp;
void solve(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
cin>>g[i][j];
//因为只能往下或者往右走
dp[i][j]=max(dp[i-1][j],dp[i][j-1])+mp[g[i][j]];
}
}
cout<<dp[n][m]<<endl;
}
int main(){
//映射
mp['l'] = 4;
mp['o'] = 3;
mp['v'] = 2;
mp['e'] = 1;
int t;
t=1;
while(t--){
solve();
}
return 0;
}
3.小红的树
考察： 树
思路：
根节点是1
先记录下每个结点的父节点，num数组代表每个结点的子树的红色节点个数。
遍历结点，如果此结点是R，更新这个节点的num值，以及向上更新父节点的num值 。自底向上更新每个节点的子树的红色节点个数。
代码如下：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5+10;
int fa[N],num[N];
char s[N];
int n,t,q,x,b;
void solve(){
scanf("%d",&n);
for(int i=2;i<=n;i++){
scanf("%d",&t);
fa[i]=t;//t是i的父节点
}
for(int i=1;i<=n;i++) {
cin>>s[i];
if(s[i]=='R'){
b=i;
num[b]++;//这个点是自己的子节点，算在里面
while(b!=1){//如果没到根节点
//更新父节点的红色子节点个数
b=fa[b];
num[b]++;
}
}
}
scanf("%d",&q);
while(q--){
scanf("%d",&x);//查询输出
printf("%d\n",num[x]);
}
}
int main(){
int t;
t=1;
while(t--){
solve();
}
return 0;
}
4.重排字符串
考察：构造
思路：
先找出里面出现最多的字母的字母次数ma, 并且用pos标记位置。
如果 2*ma>n+1,必然不行。
否则，可以。
每一轮先输出最多的那个字符，再从开始枚举，如果不是上次出现过的并且剩余个数>0的将此字母输出；
代码如下：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5+10;
int n,cnt[26],pos,ma;
string s;
void solve(){
scanf("%d",&n);
cin>>s;
for(int i=0;i<n;i++){
cnt[s[i]-'a']++;
}
for(int i=0;i<26;i++){
if(cnt[i]>ma) ma=cnt[i],pos=i;//记录下出现最多字符的次数
}
if(2*ma>n+1) puts("no");//如果次数超过了n+1,必然不行。
else{
puts("yes");
string ss;
n-=ma;
while(ma--){
ss+=(char)(pos+'a');//将出现次数最多的字符ch进行插空，每次都先拼接
for(int i=0;i<26&&n>=ma;i++){//再枚举其他字符，要满足不是ch并且出现次数>=0同时n>=ma
if(i!=pos&&cnt[i]){
ss+=(char)(i+'a');//进行拼接
//数量--
cnt[i]--;
n--;
}
}
}
cout<<ss<<endl;
}
}
int main(){
int t;
t=1;
while(t--){
solve();
}
return 0;
}
5.所谓过河
考察：并查集，计算几何
思路：
(1)dfs做法
两个圆相交的条件：
dis=sqrt((x1-x2)(x1-x2)+(y1-y2)(y1-y2))<=r1+r2;
用flag表示是否在一个集合中。
先从与河岸相交的石头开始搜索，如果能够一直搜到与河岸另一头相交的石头，表明可以过河，flag=1;
最后如果flag为1，表明所有石头和河岸在一个集合，否则不在同一个集合。
代码如下：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e4+10;
struct node{//每个圆
ll x,y,r;
}c[N];
int n,h,flag,vis[N];
void dfs(int u){
vis[u]=1;
if(c[u].y+c[u].r>=h) {//如果搜索到了与河岸另一头相交的石头了，即已经到达河岸另一端了
flag=1;
return;
}
for(int i=0;i<n;i++){
if(!vis[i]){
double dis = sqrt((c[i].x-c[u].x)*(c[i].x-c[u].x)+(c[i].y-c[u].y)*(c[i].y-c[u].y));
if(dis<=c[i].r+c[u].r){//如果满足距离小于等于两圆半径
dfs(i);//继续往下搜索
}
}
}
}
int main(){
scanf("%d%d",&n,&h);
for(int i=0;i<n;i++){
scanf("%lld%lld%lld",&c[i].x,&c[i].y,&c[i].r);
}
for(int i=0;i<n;i++){
if(flag) break;//已经在一个集合中了，break;
memset(vis,0,sizeof(vis));
if(c[i].y<=c[i].r) dfs(i);//从与河岸相交或者紧贴的石头开始搜索
}
//如果所有石头在一个集合中
if(flag) puts("Yes");
else puts("No");
return 0;
}
(2)并查集做法：
思路：
先初始化fa数组，从0-n+1,包含河的下界和上界。然后输入这些石头的坐标和半径，
先预处理河的上下界 ,
如果这个石头与下界相交或紧贴，就合并这个石头和下界。
如果这个石头与上界相交或紧贴，就合并这个石头和上界。
再处理其他石头，如果这两个石头的圆心距<=r1+r2,就合并这两个石头······
处理到最后，如果河的上界与下界在同一个集合了，表明可以过河，输出Yes;
否则输出No。
代码如下：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e4+10;
struct node{
ll x,y,r;
}c[N];
int n,h,fa[N];
int find(int x){//查找
return x==fa[x]?x:fa[x]=find(fa[x]);
}
void merge(int x,int y){ //合并
int fx=find(x),fy=find(y);
if(fx!=fy) fa[fx]=fy;
}
bool dis(int i,int j){//判断是否满足条件
double dis = sqrt((c[i].x-c[j].x)*(c[i].x-c[j].x)+(c[i].y-c[j].y)*(c[i].y-c[j].y));
if(dis<=c[i].r+c[j].r) return true;
return false;
}
int main(){
scanf("%d%d",&n,&h);
for(int i=0;i<=n+1;i++) fa[i]=i;//初始化，包括河下界和上界
for(int i=1;i<=n;i++) {
scanf("%lld%lld%lld",&c[i].x,&c[i].y,&c[i].r);
//预处理上下界
if(c[i].y<=c[i].r) merge(0,i);//如果这个石头与和下界相交或紧贴，将这个石头与河下界合并
if(c[i].y+c[i].r>=h) merge(n+1,i);//如果这个石头与和上界相交或紧贴，将这个石头与河上界合并
}
for(int i=1;i<=n;i++){
for(int j=i+1;j<=n;j++){
if(find(i)==find(j)) continue;//如果在一个集合
if(dis(i,j)) merge(i,j);//不在，并且满足条件，就合并
}
}
if(find(0)==find(n+1)) puts("Yes");
else puts("No");
return 0;
}
6.好玩的音乐游戏
考察：构造
思路：
设置一个多维字符串数组，先保存最后一行的字符串，
初始化每一行的字符串，并且储存这些新的字符进去。
接下来开始找同时的不相邻音轨，
因为不会在同一时间的同一个音轨出现两个以上音符，也不会同一时间出现超过2个音符。
所以对于每一行，用一个flag找到第一个出现的音符，标记所在位置为x,
接下来如果再次出现一个碰到同一行的下一个音符，如果满足不相邻，即x+1!=j,那么就令它们之间的字符为’-’。
最后逆序输出每一行字符串
代码如下：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2010;
int n,m,x,y,flag;
string s[N],s1;
void solve(){
scanf("%d%d",&n,&m);
s[0]="+-------+";//储存最后一行
for(int i=1;i<=m;i++){
s[i]="| |";
}
for(int i=1;i<=n;i++){
cin>>s1>>x>>y;
if(s1[0]=='t') s[x][y]='O';
else s[x][y]='X';
}
for(int i=1;i<=m;i++){
flag=0;
for(int j=1;j<=7;j++){//枚举每一列
if(s[i][j]!=' '){//如果有音符
if(flag==0){
x=j;//先标记这一行第一个出现的音符的位置
flag=1;
}
else{//等遇到了下一个音符
if((x+1)!=j){//如果不相邻
for(int k=x+1;k<j;k++){//把它们之间的空格变成'-'
s[i][k]='-';
flag=0;
}
}
}
}
}
}
for(int i=m;i>=0;i--) cout<<s[i]<<endl;
}
int main(){
int t;
t=1;
while(t--){
solve();
}
return 0;
}
314
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
