T1 字符串展开
题目描述
对于一个字符串，如果其中含有类似于“d-h”或者“4-8”的字符子串，我们就把它当作一种简写。还原输出此字符串时，用连续递增的字母或数字串替代其中的减号。上面两个子串分别输出为“defgh”和“45678”。具体约定如下：
(1) 遇到下面的情况需要对字符串进行展开：在输入的字符串中，出现了减号“-”，减号两侧同为小写字母或同为数字，且按照 ASCII 码的顺序，减号右边的字符严格大于左边的字符。
(2) 如果减号右边的字符恰好是左边字符的后继，只删除中间的减号，例如：“d-e”应输出为“de”，“3-4”应输出为“34”。如果减号右边的字符按照 ASCII 码的顺序小于或等于左边字符，输出时，要保留中间的减号，例如：“d-d”应输出为“d-d”，“3-1”应输出为“3-1”。
现在，输入一个字符串，请将此字符串展开输出。
输入格式
输入一行一个字符串，长度不超过 200，仅由数字、小写字母和减号“-”组成。行首和行末均无多余空格。
输出格式
输出一行一个字符串，为展开后的字符串。
输入输出样例
输入 #1
abcs-w-y1234-9s-4zz 输出 #1
abcstuvwxy123456789s-4zz思路
用string只需要找到“-”判断前后两个的区间就可以。
#include<bits/stdc++.h>
typedef int intt;
#define int long long
#define N 2000001
using namespace std;
string s,a;
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin>>a;
for(int i=0;i<=a.length();i++)
{
if(a[i]!='-') cout<<a[i];
else
{
int l=a[i-1];
int r=a[i+1];
if(int('0')<=l && l<=int('9') && int('0')<=r && r<=int('9') && l<r)//因为判断的是数字所以根本不需要管数字-字母的选项
{
for(int i=l+1;i<=r-1;i++)
{
cout<<char(i);
}
}
else if(int('a')<=l && l<=int('z') && int('a')<=r && r<=int('z') && l<r)
{
for(int i=l+1;i<=r-1;i++)
{
cout<<char(i);
}
}
else cout<<'-';
}
}
return 0;
}T2 懒羊羊吃草
题目描述
众所周知，懒羊羊是所有小羊里最贪吃的一只。然而，鲜为人知的是，懒羊羊也有存储粮食的习惯。而更让大家吃惊的事实是，我们的懒羊羊做事很有条理，每当他存储一份粮食时，他会专门拿出一个筐来存放。因此，他的仓库里有很多很多筐的青草。而我们的懒羊羊又是一个经常馋嘴的小羊，每当他想吃草时，就会从仓库里找出数量最少的一筐草，把它吃掉。可是懒羊羊因为草吃得太多了导致大脑运转缓慢，所以他不得不向你请求支援，帮他找出他应该吃数量为多少的青草。
输入格式
第 1 行有 1 个正整数 n，表示懒羊羊一共进行了 n 次操作。
第 2 行至第 n+1 行，每行表示一个懒羊羊的操作：当这行形式为单独一个字符‘q’时，表示懒羊羊肚子饿了，要吃掉仓库里当前数量最少的那份青草；当这行形式为一个字符‘i’和一个整数 k 时，表示懒羊羊将一份数量为 k 的青草存入了仓，‘i’和 k 之间用 1 个空格隔开。
保证每次询问时，仓库里都有草可吃，且所有操作中懒羊羊至少会吃一次草。
输出格式
输出若干行。每当输入为‘q’时，输出一行一个数，表示懒羊羊当前吃掉的那份青草的数量是多少。
输入输出样例
输入 #1
5
i 5
i 2
q
i 9
q输出 #1
2
5 思路
本题用了一个降序队列，属于是投机取巧，但很好用
代码
#include<bits/stdc++.h>
using namespace std;
typedef int intt;
#define int long long
priority_queue < int , vector < int > , greater < int > > q; //开一个降序的队列，这个我也不会看网上的
int ans,a[1000005],n,x,i,j,k;
intt main()
{
// freopen("in.in","r",stdin);
// freopen("std.out","w",stdout);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
char ch;
cin>>n;
for(int i=0;i<n;i++)
{
cin>>ch;
if(ch=='i')
{
cin>>x; //如果是i，就放到队列中
q.push(x);
}
if(ch=='q')
{
a[j++]=q.top(); //如果是q，就将队头的值赋给a数组，并加队头移出队列
q.pop();
}
}
for(int i=0;i<j;i++) cout<<a[i]<<endl;
return 0；
}T3 方格稿纸
题目描述
小 y 终于在小学学会了一些字、词、句子，会写一点作文了。某一天，小 y 买了一张方格稿纸来写作文，稿纸是 n 行 m 列的。
某天小 y 的邻居小小 x 来小 y 家玩，无聊地用黑墨水笔把小 y 新买的方格稿 纸涂黑了很多格子。每个格子不是完全黑色就是完全白色。
小 y 不能责怪小 x。作文写不成了，他也觉得很无聊，就开始数里面有多少 “魔幻方阵”。如果稿纸中一个 k×k 的正方形区域满足以下两个条件，那么它就 是魔幻方阵：
（1）黑白格子的数量差不能超过1；
（2）k不能小于2。
上图染色后的方格稿纸共有 9 个魔幻方阵（6 个 2×2 的魔幻方阵，3 个 3×3 的魔幻方阵）。 现在，请你帮助小 y 编程计算被染色的稿纸里面有多少个魔幻方阵。
输入格式
第一行有 2 个正整数 n 和 m（之间以一个空格分隔），表示 n 行 m 列的稿纸。
接下来 n 行，每行有 m 个 0 或 1 的整数（之间以一个空格分隔），代表这一行中每一个格子的颜色。如果这个数是 1 则为黑色，是 0 则为白色。
输出格式
输出一行一个整数，表示稿纸中魔幻方阵的个数。
输入输出样例
输入 #1
5 5
1 0 1 1 1
1 0 1 0 1
1 1 0 1 1
1 0 0 1 1
1 1 1 1 1 输出 #1
9 思路
二维前缀和。给了图例可能要好像一点。对于样例做一个解释。
例如找到一个点，我们需要算一个区间是如下
所以我们的公式即为
剩下的就判断条件就可以了。
代码
#include<bits/stdc++.h>
using namespace std;
typedef int intt;
#define int long long
#define maxn 1005
int n,m;
int ans=0;
int a[maxn][maxn],b[maxn][maxn];
intt main()
{
// freopen("in.in","r",stdint);
// freopen("std.out","w",stdout);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin>>n>>m;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
cin>>a[i][j];
b[i][j]=b[i][j-1]+a[i][j]+b[i-1][j]-b[i-1][j-1];
}
}
for(int i=2;i<=min(n,m);i++)
{
for(int x=1;x<=n-i+1;x++)
{
for(int y=1;y<=m-i+1;y++)
{
int cnt=0;
int xx=x+i-1;
int yy=y+i-1;
cnt=b[xx][yy]-b[x-1][yy]-b[xx][y-1]+b[x-1][y-1];
if(cnt-(i*i-cnt)<=1&&cnt-(i*i-cnt)>=-1) ans++;
}
}
}
cout<<ans;
return 0;
} T4 线段颜色条数
题目描述
X轴上从下向上依次叠放一定长度的某种颜色的线段。问从上向下看X轴，它被分成了不同颜色的多少段？
输入格式
第1行：2个整数XC，N。XC表示X轴的颜色，1<=N<=100000，表示线段的条数，其中X轴的范围为[-100000,100000]
接下来N行，每行3个整数L，R，C，-100000 <=L<=R<= 100000，表示一线段的左、右端点；0<=C<=100000，表示线段的颜色。
输出格式
文件输出只有一行仅为一个整数M，表示X轴被分成不同颜色的多少段。
输入输出样例
输入 #1
1 4
2 6 2
1 5 3
3 4 2
7 8 4输出 #1
8思路
以前有过老师自己出的一道题：染色。几乎一样，用线段数加一个lazy标记就可以。建议还是自己画一下图
在加一个color来判断记录颜色就可以。
代码
#include <bits/stdc++.h>
using namespace std;
typedef int intt;
#define int long long
#define maxm 2000005
#define maxn 305
const int inf=0x3f3f3f3f;
#define lc k<<1
#define rc k<<1|1
int n,m,Maxx=-inf,Minn=inf,ans,b[maxn];
struct node
{
int x,y,c;
}a[maxm];
struct Seg
{
int l,r,cl,cr,lz,sum;
}tree[maxm];
void pushdown(int k)
{
if(tree[k].lz==-1)return ;
tree[lc].sum=tree[rc].sum=1;
tree[lc].cl=tree[lc].cr=tree[k].lz;
tree[rc].cl=tree[rc].cr=tree[k].lz;
tree[lc].lz=tree[rc].lz=tree[k].lz;
tree[k].lz=-1;
}
void pushup(int k)
{
tree[k].sum=tree[lc].sum+tree[rc].sum;
tree[k].cl=tree[lc].cl;
tree[k].cr=tree[rc].cr;
if(tree[lc].cr==tree[rc].cl)tree[k].sum--;
}
void Build(int k,int l,int r)
{
tree[k]=((Seg){l,r,m,m,-1,1});
if(l==r)return ;
int mid=(l+r)>>1;
Build(lc,l,mid);
Build(rc,mid+1,r);
}
void Set(int k,int l,int r,int c)
{
if(tree[k].l>r||tree[k].r<l)return ;
if(tree[k].l>=l&&tree[k].r<=r)
{
tree[k].sum=1;
tree[k].lz=tree[k].cl=tree[k].cr=c;
return;
}
pushdown(k);
Set(lc,l,r,c);
Set(rc,l,r,c);
pushup(k);
}
void Sum(int k,int t){
if(tree[k].l>t||tree[k].r<t)return;
if(tree[k].l==tree[k].r)
{
if(tree[k].cl!=m)ans++;
return;
}
pushdown(k);
Sum(lc,t);
Sum(rc,t);
pushup(k);
}
intt main()
{
// freopen("in.in","r",stdin);
// freopen("std.out","w",stdout);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin>>m>>n;
for(int i=1;i<=n;i++)
{
cin>>a[i].x>>a[i].y>>a[i].c;
a[i].x+=100001;
a[i].y+=100000;
Minn=min(Minn,a[i].x);
Maxx=max(Maxx,a[i].y);
}
Build(1,Minn,Maxx);
for(int i=1;i<=n;i++)
{
Set(1,a[i].x,a[i].y,a[i].c);
}
ans+=tree[1].sum;
Sum(1,Minn);
Sum(1,Maxx);
cout<<ans;
return 0;
}T5 幻像迷宫（洛谷P1363）
题目描述
幻象迷宫可以认为是无限大的，不过它由若干个 N×M 的矩阵重复组成。矩阵中有的地方是道路，用 .. 表示；有的地方是墙，用 # 表示。LHX 和 WD 所在的位置用 S 表示。也就是对于迷宫中的一个点(x,y)，如果 (x mod n,y mod m) 是 . 或者 S，那么这个地方是道路；如果 (x mod n,y mod m) 是#，那么这个地方是墙。LHX 和 WD 可以向上下左右四个方向移动，当然不能移动到墙上。
请你告诉 LHX 和 WD，它们能否走出幻象迷宫（如果它们能走到距离起点无限远处，就认为能走出去）。如果不能的话，LHX 就只好启动城堡的毁灭程序了……当然不到万不得已，他不想这么做。
输入格式
输入包含多组数据，以 EOF 结尾。
每组数据的第一行是两个整数N,M。
接下来是一个 N×M 的字符矩阵，表示迷宫里 (0,0)(0,0) 到 (n−1,m−1) 这个矩阵单元。
输出格式
对于每组数据，输出一个字符串，Yes 或者 No。
输入输出样例
输入
5 4
##.#
##S#
#..#
#.##
#..#
5 4
##.#
##S#
#..#
..#.
#.##输出
Yes
No
思路
如题所示，这是一道洛谷原题。所以也可以在洛谷上看题解，肯定比我的详细。
最暴力算法
这道题的难点就在于判断是否走完。而大多数人最开始的思路就是先做出周围的图，如果s可以走到另一个图的s就可以了。虽然的不满但认为50还是可以。但是出题人出的数据非常nb精妙，就会出现以下这几种情况
他是可以走到s点的。但我们的搜索范围只有周围的几个图。如果搜下去，试想一下，极限图为1500，那我们最多也只能搜3个图，这样就会出现问题。
所以就推出了第二种最优解
最优解
所以不能拓展迷宫而对坐标取模就好了.
如果走到过某个点现在又走到了这个点，那显然是可以走无限远的。
现在出现了一些~~（堆）~~问题：
如何判断是否走到过这个点呢？
有一个比较巧妙的方法：
记录取模的横纵坐标=x, y时，同时记录没有取模的坐标lx, ly
当第一次走这个迷宫的时候，x, y和lx, ly肯定是分别相等的
所以只要走到的一个点的x, y和lx, ly不相等（xlx ∣∣ y
ly），那这个点一定是被走了第二遍.
#include<bits/strdc++.h>>
using namespace std;
const int MAXN = 1500 + 1;
const int dx[4] = {1, -1, 0, 0};
const int dy[4] = {0, 0, 1, -1};
int n, m;
int st_x, st_y;
int vis[MAXN][MAXN][3];
bool fl, a[MAXN][MAXN];
char ch;
void dfs(int x, int y, int lx, int ly) {
if(fl) return;
if(vis[x][y][0] && (vis[x][y][1]!=lx || vis[x][y][2]!=ly)) {
fl = 1;
return;
}
vis[x][y][1] = lx, vis[x][y][2] = ly, vis[x][y][0] = 1;
for(int i=0; i<4; ++i) {
int xx = (x + dx[i] + n) % n, yy = (y + dy[i] + m) % m;
int lxx = lx + dx[i], lyy = ly + dy[i];
if(!a[xx][yy]) {
if(vis[xx][yy][1]!=lxx || vis[xx][yy][2]!=lyy || !vis[xx][yy][0])
dfs(xx, yy, lxx, lyy);
}
}
}
int main() {
ios::sync_with_stdio(false);
while(cin >> n >> m) {
fl = 0;
memset(a, 0, sizeof(a));
memset(vis, 0, sizeof(vis));
for(int i=0; i<n; ++i)
for(int j=0; j<m; ++j) {
cin >> ch;
if(ch == '#') a[i][j] = 1;
if(ch == 'S') st_x = i, st_y = j;
}
dfs(st_x, st_y, st_x, st_y);
if(fl) puts("Yes");
else puts("No");
}
return 0;
}
扫一扫
1038
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
