算法训练 DAY-1

唯念月色凉_

已于 2023-07-18 15:45:49 修改

阅读量809

点赞数 1

文章标签：算法学习 c++ 笔记

于 2023-07-17 22:58:09 首次发布

本文链接：https://blog.csdn.net/w1520358997/article/details/131766399

版权

暑假训练day-1

一、洛谷P5440 【XR-2】奇迹
二、P1434 [SHOI2002] 滑雪
三、The Lakes
四、Gold Rush
五、Fall Down
六、选数

一、洛谷P5440 【XR-2】奇迹

题目描述

我们称一个日期为一个八位数，第 1~4 位构成年，第 5~6 位构成月，第 7~8 位构成日，不足位数用 0 补足。同时，要求日期所代表的这一天真实存在，且年的范围为 1~9999。

出现奇迹的日期都存在相同的特点：由“日”组成的两位数，由“月+日”组成的四位数，由“年+月+日”组成的八位数均为质数。但并不是所有存在这样特点的日期都一定会出现奇迹。

现在，你得到了一个可能会出现奇迹的日期，然而不幸的是这个日期却是残缺的，八位中可能有若干位无法确定。你需要知道这个日期有多少种可能，这样你才能做好充足的准备去迎接奇迹的到来。

输入格式

本题有多组数据。

第一行一个正整数 $T$ ，表示数据组数。

接下来的 $T$ 行，每行一个八位字符串。其中第 $i$ 位如果为 -，则表示日期的第 $i$ 位无法确定，否则表示日期的第 $i$ 位为字符串中第 $i$ 位上的数字。

输出格式

对每组数据，一行一个整数，表示答案。

样例1

2
53-7-3-7
20190629

样例输出1

6
0

提示

【样例 $1$ 说明】

53-7-3-7 的 $6$ 种可能的日期如下：

【数据规模与约定】

一共 $10$ 个测试点，记 $c$ 为八位字符串中 - 的个数。

对前 $9$ 个测试点，在第 $i$ 个测试点中保证 $c = i - 1$ 。

对 $100\%$ 的数据保证 $\le T \le 10$ 。

代码实现

#include<bits/stdc++.h>
using namespace std;
#define ios ios::sync_with_stdio(0); cin.tie(0),cout.tie(0);
const int N = 100010;
int cnt;
string s;
int ans;
int pri[N];
bool st[N];
int de[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
bool ff(int n)
{
    if(n<2)
    {
        return false;
    }
    for(int i = 2;i <= n/i;i++)
    {
        if(n%i==0)
        {
            return false;
        }
    }
    return true;
}
bool checkdate(int n)
{
    int day = n % 100;
    int mon = n % 10000 / 100;
    int year = n /10000;
    if(year < 1 || year > 9999 ) return false;
    if(mon < 1 ||  mon >12) return false;
    if(mon == 2)
    {
        if(day == 29 && ((year % 4 == 0) && (year % 100 != 0) ||  year % 400 == 0))
        {
            return true;
        }
    }
 
    if(day >= 1 && day <= de[mon]){
            return true;
    }
    return false;
}
bool checkprim(int n)
{
    int day = n % 100;
    int md = n % 10000;
    if(pri[day] == 1&& pri[md] == 1&& ff(n))
    {
        return true;
    }
    return false;
}
void dfs(int u,int v)
{
    if(u == 8)
    {
        int tt = v;
        if(checkdate(tt) && checkprim(tt))
        {
            ans++;
        }
        return;
    }
    if(s[u] == '-')
    {
        for(int i=0;i<=9;i++)
        {
            int r = v * 10 + i;
            dfs(u+1,r);
        }
    }else
    {
        dfs(u+1,v*10+(s[u] - '0'));
    }
}
void solve()
{
    cin>>s;
    ans = 0;
    if(cnt == 8)
    {
        cout<<"55157";
    }else
    {
        dfs(0,0);
        cout<<ans;
    }
}
int main()
{
    ios
    for(int i=2;i<=1240;i++)
    {
        if(pri[i] == 0)
        {
            pri[i] = 1;
            for(int j=i+i;j<=1240;j+=i)
            {
                pri[j] = -1;
            }
        }
    }
    int t;
    cin>>t;
    while(t --)
    {
        solve();
        cout<<endl;
    }
    return 0;
}

总结：此题用普通dfs会TLE，我们选择对其进行优化，主要优化的地方有2个，一个是使用欧拉筛的思想先把需要判断的素数都存在数组里，需要判断时直接O(1)询问可以大大减少时间，第二个是对日期的判断，通过判断闰年的方法可以排除是素数，减少使用试除法判断素数的次数。

二、P1434 [SHOI2002] 滑雪

题目描述

Michael 喜欢滑雪。这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael 想知道在一个区域中最长的滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子：

1   2   3   4   5
16  17  18  19  6
15  24  25  20  7
14  23  22  21  8
13  12  11  10  9

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度会减小。在上面的例子中，一条可行的滑坡为 $24 - 17 - 16 - 1$ （从 $24$ 开始，在 $1$ 结束）。当然 $25$ － $24$ － $23$ － $\ldots$ － $3$ － $2$ － $1$ 更长。事实上，这是最长的一条。

输入格式

输入的第一行为表示区域的二维数组的行数 $R$ 和列数 $C$ 。下面是 $R$ 行，每行有 $C$ 个数，代表高度(两个数字之间用 $1$ 个空格间隔)。
输出格式

输出区域中最长滑坡的长度。

样例1：

5 5
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

样例输出1

提示

对于 $100\%$ 的数据， $1\leq R,C\leq 100$ 。

三、The Lakes

题面翻译

给定 $n\times m$ 的矩阵，正整数上、下、左、右相连构成一个连通块。定义一个连通块的权值为该连通块中所有数的和。求矩阵中最大的连通块。

题目描述

You are given an $\times m$ grid $a$ of non-negative integers. The value $a_{i,j}$ represents the depth of water at the $i$ -th row and $j$ -th column.

A lake is a set of cells such that:

each cell in the set has $a_{i,j} > 0$ , and
there exists a path between any pair of cells in the lake by going up, down, left, or right a number of times and without stepping on a cell with $a_{i,j} = 0$ .

The volume of a lake is the sum of depths of all the cells in the lake.

Find the largest volume of a lake in the grid.

输入格式

The first line contains a single integer $t$ ( $\leq t \leq 10^4$ ) — the number of test cases.

The first line of each test case contains two integers $n, m$ ( $\leq n, m \leq 1000$ ) — the number of rows and columns of the grid, respectively.

Then $n$ lines follow each with $m$ integers $a_{i,j}$ ( $\leq a_{i,j} \leq 1000$ ) — the depth of the water at each cell.

It is guaranteed that the sum of $\cdot m$ over all test cases does not exceed $10^6$ .

输出格式

For each test case, output a single integer — the largest volume of a lake in the grid.

样例输入 1

样例输出1

代码

#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> PII;
typedef long long LL;
#define ios ios::sync_with_stdio(0); cin.tie(0),cout.tie(0);
const int N = 3010;
int ans;
int a[N][N];
int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};
int n,m;
void dfs(int u,int v)
{
	ans += a[u][v];
	a[u][v] = 0;
    for(int i = 0;i < 4;i++)
    {
        int x = dx[i] + u;
        int y = dy[i] + v;
        if(x <= 0 || x > n || y <= 0 || y > m || !a[x][y]) continue;
        if(a[x][y]) ans += a[x][y];
        a[x][y] = 0;
        dfs(x,y);
    }
}
void solve()
{
	int res = 0;
	cin>>n>>m;
	for(int i = 1;i <= n;i ++)
	{
		for(int j = 1;j <= m;j ++)
		{
			cin>>a[i][j];
		}
	}
	for(int i = 1;i <= n;i ++)
	{
		for(int j = 1;j <= m;j ++)
		{
			if(a[i][j])
			{
				ans = 0;
				dfs(i,j);
				res = max(res,ans);
			}
		}
	}
	cout<<res;
}
int main()
{
    ios
    int _;
    cin>>_;
    while(_--)
    {
        solve();
        cout<<endl;
    }
    return 0;
}

总结：由于有多个输入，所以不能使用memset函数，否则会严重TLE，我想到了一种很好的优化方式，已知二维数组中所有不为0的位置都会走一遍，所以在走过每个位置的时候，把这个位置赋值为0，这样再遍历完所有的位置之后，数组也就转变成为没有初始化的状态。

四、Gold Rush

题意简述
本题有 $t$ 组数据。对于每组数据，你都会得到 $n$ 个金币。

现在，你可以对这 $n$ 个金币进行分堆。每次分堆只能分成两堆，并且需要使分堆后的一堆恰好是另一堆的两倍。同时，分成的两堆都必须有整数个金币。

请你判断：在经过多次或不经过分堆后能否有任意一堆的金币数为 $m$ 。如果可以，请输出 YES 或其它任意的大小写形式；否则，请输出 NO 或其它任意的大小写形式。

样例解释
对于样例一中的第一组数据，我们可以采用如图的形式分堆：

对于第二组数据，它可以采用如下的分堆方式：

$\{\color{red}9\color{black}\}\to\{\color{red}6\color{black},3\}\to\{4,2,3\}$

在每次分堆前，被分开的堆被标为红色。

对于第三组数据，我们无法进行分堆操作。

对于第四组数据，我们不能把少的金币变成更多的一堆。

题目描述

Initially you have a single pile with $n$ gold nuggets. In an operation you can do the following:

Take any pile and split it into two piles, so that one of the resulting piles has exactly twice as many gold nuggets as the other. (All piles should have an integer number of nuggets.)

One possible move is to take a pile of size $6$ and split it into piles of sizes $2$ and $4$ , which is valid since $4$ is twice as large as $2$ .

Can you make a pile with exactly $m$ gold nuggets using zero or more operations?

输入格式

The first line contains an integer $t$ ( $\leq t \leq 1000$ ) — the number of test cases.

The only line of each test case contains two integers $n$ and $m$ ( $\leq n, m \leq 10^7$ ) — the starting and target pile sizes, respectively.

输出格式

For each test case, output “YES” if you can make a pile of size exactly $m$ , and “NO” otherwise.

样例 #1

11
6 4
9 4
4 2
18 27
27 4
27 2
27 10
1 1
3 1
5 1
746001 2984004

样例输出 #1

YES
YES
NO
NO
YES
YES
NO
YES
YES
NO
NO

提示

The first test case is pictured in the statement. We can make a pile of size $4$ .

In the second test case, we can perform the following operations: $\{\color{red}{9}\} \to \{\color{red}{6},3\} \to \{4,2,3\}$ . The pile that is split apart is colored red before each operation.

In the third test case, we can’t perform a single operation.

In the fourth test case, we can’t end up with a larger pile than we started with.

代码

#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> PII;
typedef long long LL;
#define ios ios::sync_with_stdio(0); cin.tie(0),cout.tie(0);
const int N = 2e5+10;
bool dfs(int a,int b)
{
    if(a == b) return true; //如果相等 则目标达成
    if(a%3!=0 || a < b) return false; //如果要分出2:1的比例 则至少要被三整除
    /*下一个状态有两种情况，二者有一个成立即可
    	1.一个是1/3的情况 (a/3)
    	2.一个是2/3的情况 (a - a/3)
    */
    return dfs(a/3,b) || dfs(a - a/3,b); 
}
void solve()
{
    int a,b;
    cin>>a>>b;
    if(dfs(a,b)) cout<<"YES";
    else cout<<"NO";
}
int main()
{
    ios
    int _;
    cin>>_;
    while(_--)
    {
        solve();
        cout<<endl;
    }
    return 0;
}

总结：在某些题目中，dfs可以搜索多种情况的不同状态

五、Fall Down

题面翻译

有一个 $n\times m$ 的网格（ $\leq n, m \leq 50$ ），其中每个格子上有三种情况：

o字符：此块为一个石子
*字符：此块为障碍物，石子不能通过。
.字符：此块为空，石子可以通过。

每块石子回往下落，直到它落在了网格最下面一行、障碍物的上面一格或已落下的石子上面一格

给出原式网格，求石子落下后的网格。

题目描述

There is a grid with $n$ rows and $m$ columns, and three types of cells:

An empty cell, denoted with ‘.’.
A stone, denoted with ‘*’.
An obstacle, denoted with the lowercase Latin letter ‘o’.

All stones fall down until they meet the floor (the bottom row), an obstacle, or other stone which is already immovable. (In other words, all the stones just fall down as long as they can fall.)

Simulate the process. What does the resulting grid look like?

输入格式

The input consists of multiple test cases. The first line contains an integer $t$ ( $\leq t \leq 100$ ) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers $n$ and $m$ ( $\leq n, m \leq 50$ ) — the number of rows and the number of columns in the grid, respectively.

Then $n$ lines follow, each containing $m$ characters. Each of these characters is either ‘.’, ‘*’, or ‘o’ — an empty cell, a stone, or an obstacle, respectively.

输出格式

For each test case, output a grid with $n$ rows and $m$ columns, showing the result of the process.

You don’t need to output a new line after each test, it is in the samples just for clarity.

样例输入 #1

3
6 10
.*.*....*.
.*.......*
...o....o.
.*.*....*.
..........
.o......o*
2 9
...***ooo
.*o.*o.*o
5 5
*****
*....
*****
....*
*****

样例输出 #1

..........
...*....*.
.*.o....o.
.*........
.*......**
.o.*....o*

....**ooo
.*o**o.*o

.....
*...*
*****
*****
*****

代码

#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> PII;
typedef long long LL;
#define ios ios::sync_with_stdio(0); cin.tie(0),cout.tie(0);
const int N = 100010,M = 2010,INF = 0x3f3f3f3f;
int gcd(int a,int b){
return b?gcd(b,a%b):a;
}
char a[100][100];
int n,m;
void dfs(int u,int v)
{
    if(a[u+1][v] == 'o' || (u+1) == n || a[u+1][v] == '*')
    {
        return;
    }
    else
    {
        swap(a[u][v],a[u+1][v]);
        dfs(u+1,v);
    }
}
void solve()
{
    cin>>n>>m;
    for(int i = 0;i < n;i ++)
    {
    	for(int j = 0;j < m;j ++)
    	{
    		cin>>a[i][j];
    	}
    }
    for(int i = n-2;i >= 0;i --)
    {
        for(int j = 0;j < m;j ++)
        {
            if(a[i][j] == '*')
            {
                dfs(i,j);
            }
        }
    }
    for(int i = 0;i < n;i ++)
    {
        for(int j = 0;j < m;j ++)
        {
            cout<<a[i][j];
        }
        cout<<endl;
    }
}
int main()
{
    ios
    int t;
    cin>>t;
    while(t --)
    {
        solve();
        cout<<endl;
    }
    return 0;
}

总结：模板题

六、选数

题目描述

已知 $n$ 个整数 $x_1,x_2,\cdots,x_n$ ，以及 $1$ 个整数 $k$ （ $k < n$ ）。从 $n$ 个整数中任选 $k$ 个整数相加，可分别得到一系列的和。例如当 $n = 4$ ， $k = 3$ ， $4$ 个整数分别为 $3, 7, 12, 19$ 时，可得全部的组合与它们的和为：

$3 + 7 + 12 = 22$

$3 + 7 + 19 = 29$

$7 + 12 + 19 = 38$

$3 + 12 + 19 = 34$

现在，要求你计算出和为素数共有多少种。

例如上例，只有一种的和为素数： $3 + 7 + 19 = 29$ 。

输入格式

第一行两个空格隔开的整数 $n, k$ （ $\le n \le 20$ ， $k < n$ ）。

第二行 $n$ 个整数，分别为 $x_1,x_2,\cdots,x_n$ （ $\le x_i \le 5\times 10^6$ ）。

输出格式

输出一个整数，表示种类数。

样例输入 #1

4 3
3 7 12 19

样例输出 #1

代码

#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> PII;
typedef long long LL;
#define ios ios::sync_with_stdio(0); cin.tie(0),cout.tie(0);
const int N = 100010,M = 2010,INF = 0x3f3f3f3f;
int gcd(int a,int b){
return b?gcd(b,a%b):a;
}
int a[N];
int ans = 0;
int n,m;
bool ff(int n)
{
	if(n < 2) return 0;
	for(int i = 2;i <= n / i;i ++)
	{
		if(n % i == 0) return 0;
	}
	return 1;
}
void dfs(int u,int v,int k)
{
	if(u == m)
	{
		if(ff(v))
		{
			ans ++;
		}
		return ;
	}
	for(int i = k;i < n;i ++)
	{
		dfs(u+1,v+a[i],i + 1);
	}
}
void solve()
{
	cin>>n>>m;
	for(int i = 0;i < n;i ++) cin>>a[i];
	dfs(0,0,0);
	cout<<ans;
}
int main()
{
    ios
    solve();
    return 0;
}

总结：模板题

唯念月色凉_

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
3
评论
算法训练 DAY-1

可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。数组的每个数字代表点的高度。现在，你得到了一个可能会出现奇迹的日期，然而不幸的是这个日期却是残缺的，八位中可能有若干位无法确定。为一个八位数，第 1~4 位构成年，第 5~6 位构成月，第 7~8 位构成日，不足位数用 0 补足。同时，要求日期所代表的这一天真实存在，且年的范围为 1~9999。出现奇迹的日期都存在相同的特点：由“日”组成的两位数，由“月+日”组成的四位数，由“年+月+日”组成的八位数均为。
复制链接

扫一扫