每日学习录

最新推荐文章于 2024-10-11 17:04:33 发布

随风佛

最新推荐文章于 2024-10-11 17:04:33 发布

阅读量891

点赞数 15

文章标签：学习

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/2301_80642211/article/details/136261041

版权

目录

P2080 增进感情

P1434 [SHOI2002] 滑雪

题目描述编辑

P7793 [COCI2014-2015#7] ACM

P1364 医院设置

P1629 邮递员送信

P1656 炸铁路

P1296 奶牛的耳语

L-shapes

题目描述

思路：

从上往下，从左往右逐个搜索：

先判断每个 * 是不是满足 L 形状；

再判断每个 * 周围八个方向是否只有两个 * 。

代码如下：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 110;
int n, m;
char mp[N][N]; 
int vis[N][N];
bool check(int x, int y)
{
    int sum = 0;
    for (int i = -1; i <= 1; i++){
        for (int j = -1; j <= 1; j++){
            if (mp[x + i][y + j] == '*')
                sum ++;
        }
    }
    if (sum == 3) 
        return true;
    return false;
}
bool get(int x, int y)
{
    vis[x][y] = 1;
    int sum = 1;
    if (mp[x][y + 1] == '*'){
        vis[x][y + 1] = 1;
        sum++;
    }
    if (mp[x + 1][y - 1] == '*'){
        vis[x + 1][y - 1] = 1;
        sum++;
    }
    if (mp[x + 1][y] == '*'){
        vis[x + 1][y] = 1;
        sum++;
    }
    if (mp[x + 1][y + 1] == '*'){
        vis[x + 1][y + 1] = 1;
        sum++;
    }
    if (sum == 3)
        return true;
    return false;
}
void solve()
{
    memset(mp, 'a', sizeof(mp));
    memset(vis, 0, sizeof(vis));
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        scanf("%s", mp[i] + 1);
    int flag = 1;
    for (int i = 1; i <= n; i++){
        for (int j = 1; j <= m; j++){
            if (mp[i][j] == '*' && vis[i][j] == 0){
                if (!get(i, j))
                    flag = 0;
            }
            if (mp[i][j] == '*'){
                if (!check(i, j))
                    flag = 0;
            }
        }
    }
    if (flag)
        cout << "YES" << endl;
    else
        cout << "NO" << endl;
}
int main()
{
    int t;
    cin >> t;
    while (t--){
        solve();
    }
    return 0;
}

P2080 增进感情

题目背景

思路

将好感度x+y作为体积，幸福度x-y作为作为价值，然后就是一个经典的背包问题了。还可以特判一下，因为幸福度为0时就是最小。

#include<bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f;
int f[100001], tot;
struct node{
    int w, v;
}a[110];
bool cmp(node a, node b){
    return a.w > b.w;
}
int N, V, ans = INF;
int main(){
    cin >> N >> V;
    for (int i = 1; i <= N; ++i){
        int c, b;
        cin >> c >> b;
        a[i].v = b - c;
        a[i].w = c + b;
        if (c + b > 0)tot += a[i].w;
    }
    if (tot < V){ cout << -1 << endl; return 0; }
    memset(f, INF, sizeof(f));
    f[0] = 0;
    sort(a + 1, a + N + 1, cmp);
    for (int i = 1; i <= N; ++i){
        for (int j = tot; j >= a[i].w; --j){
            if (abs(f[j - a[i].w] + a[i].v) < abs(f[j])){
                f[j] = f[j - a[i].w] + a[i].v;
                if (f[j] == 0 && j >= V){
                    cout << 0 << endl;
                    return 0;
                }
            }
        }
    }
    for (int i = V; i <= tot; ++i)
    if (abs(f[i]) < ans)ans = abs(f[i]);
    if (ans == INF)cout << -1 << endl;
    else cout << ans << endl;
    return 0;
}

P1434 [SHOI2002] 滑雪

题目描述

思路

很显然，直接dfs会TLE。那么就需要记忆化来优化。

用s[i][j]表示从(i,j)点出发能走的最长距离。

每次搜索一次记忆一次即可。

下面给刚接触不怎么明白的人举例：(已经理解的人跳过)

由于样例不好讲我自己举例子：

3 3
1 1 3
2 3 4
1 1 1

先去找(1,1)的最长距离，很明显为1

接着找(1,2)的最长距离，很明显为1

接着找(1,3)的最长距离，为2((1,3)->(1,2))

然后找(2,1)的最长距离，为2((2,1)->(1,1))

然后是(2,2)的最长距离，如果没有记忆化，那么搜索过程为：(2,2)->(2,1)->(1,1)

但是（2,1）之前已经搜过了，再去搜就是浪费时间，之前搜索已经知道(2,1)的值为2，那么搜索过程就是缩短为：(2,2)->(2,1),即为3。

代码如下：

#include <bits/stdc++.h>
using namespace std;
int n, m;
int mp[110][110];
int ans = -100;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int s[110][110];
int dfs(int x, int y)
{
    if (s[x][y])
        return s[x][y];
    s[x][y] = 1;
    for (int i = 0; i < 4; i++)
    {
        int xx = x + dx[i];
        int yy = y + dy[i];
        if (xx > 0 && xx <= n && yy > 0 && yy <= m && mp[x][y] > mp[xx][yy])
        {
            dfs(xx, yy);
            s[x][y] = max(s[x][y], s[xx][yy] + 1);
        }
    }
    return s[x][y];
}
int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            cin >> mp[i][j];
        }
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            ans = max(ans, dfs(i, j));
        }
    }
    cout << ans << endl;
    return 0;
}

P7793 [COCI2014-2015#7] ACM

题目背景

思路

先枚举每个人负责那一段，dp[i][j]就代表第一段到j为止的最小代价

$dp[1][i]=dp[1][i-1]+a[i]$ ，a【i】表示第一段负责人对第i个问题的代价

$dp[2][i]=min \left \{ dp[1][i-1],dp[2][i-1] \right \} +b[i]$ ，b【i】表示第二段负责人对第i个问题的代价

$dp[3][i]=min \left \{ dp[1][i-1],dp[2][i-1],dp[3][i-1] \right \} +c[i]$ ，c【i】表示第二段负责人对第i个问题的代价

然后答案就出来了（感觉比dfs好想多了）

代码如下：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int d[5][1500100];
int s[5][1500100];
int nxt[5];
int dp[5][150100];
int INF=0x3f3f3f3f;
int n;
int solve(int a,int b,int c)
{
	memset(dp,0x3f,sizeof(dp));
    dp[1][1]=d[a][1],dp[1][2]=d[a][1]+d[a][2],dp[2][2]=d[a][1]+d[b][2];
    for(int i=3;n>=i;i++) {
    	dp[1][i]=dp[1][i-1]+d[a][i];
        dp[2][i]=min(dp[1][i-1],dp[2][i-1])+d[b][i];
        dp[3][i]=min(dp[1][i-1],min(dp[2][i-1],dp[3][i-1]))+d[c][i];
    }
    return dp[3][n];
}
int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin>>n;
	for(int i=1;i<=3;++i)
	{
		for(int j=1;j<=n;j++)cin>>d[i][j];
	}
	for(int i=1;i<=3;i++)
	{
		for(int j=1;j<=n;j++)s[i][j]=s[i][j-1]+d[i][j];
	}
	int ans=0x3f3f3f3f;
	int a[5]={1,2,3};
	do
	{
		int res=solve(a[0],a[1],a[2]);
		if(res<ans)ans=res;
	}while(next_permutation(a,a+3));
	cout<<ans<<'\n';
	return 0;
}

P1364 医院设置

题目描述

思路

经典的二叉树例题。

#include<stdio.h>
#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;
int n,ans=100000000,vis[110];
struct node{
	int left,right,father,value;
}tree[110];
int cal(int x,int d){
	if(!x || vis[x]) return 0;
	vis[x] = 1;
	return cal(tree[x].left,d+1) + cal(tree[x].right,d+1)
		+cal(tree[x].father,d+1) + tree[x].value * d;
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++)
		cin>>tree[i].value>>tree[i].left>>tree[i].right;
	for(int i=1;i<=n;i++){
		tree[tree[i].left].father = i;
		tree[tree[i].right].father = i;
	}
	for(int i=1;i<=n;i++){
		memset(vis,0,sizeof(vis));
		ans = min(ans,cal(i,0));
	}
	cout<<ans;
	return 0;
}

P1629 邮递员送信

题目描述

思路

1.单源最短路径题目，推荐用Dijkstra算法。

2.注意是来回两个方向，所以需要反向建图。（邻接表/邻接矩阵都行）

3.注意翻转数组，反向建图。

4.以及邻接矩阵的初始化（自己本身的点仍为0，其余点均设为无穷大），初始赋值（从1点到各个结点的时间）。

代码如下：

#include<bits/stdc++.h>
using namespace std;
int mp[1010][1010],dis[1010];
const int INF=1e9;
int i,j;
void init(int n);//初始化邻接矩阵
void dijkstra(int n);
void over(int n);//翻转邻接矩阵，即反向建立邻接矩阵
void lujing(int n);//将1到各个点初始赋值
int main()
{
    int n,m,x,y,w;
    int sum;
    cin>>n>>m;
    init(n);
    for(i=1;i<=m;i++)
    {
        cin>>x>>y>>w;
        mp[x][y]=min(mp[x][y],w);//建图，防止重复边
    }
    lujing(n);
    dijkstra(n);
    for(i=1;i<=n;i++)
    {
        sum+=dis[i];
    }
    over(n);//翻转邻接矩阵
    lujing(n);
    dijkstra(n);
    for(i=1;i<=n;i++)
    {
        sum+=dis[i];
    }
    cout<<sum<<endl;
}
void init(int n)//邻接矩阵初始化
{
    for(i=1;i<=n;i++)
    {
        for(j=1;j<=n;j++)
        {
            if(i!=j)
            mp[i][j]=INF;
        }
    }
}
void dijkstra(int n)//单源最短路径
{
    bool vis[1010]={0};
    vis[1]=1;
    for(i=1;i<n;i++)
    {
        int min=INF;int index;
        for(j=1;j<=n;j++)
        {
            if(!vis[j]&&min>dis[j])
            {
                min=dis[j];
                index=j;
            }
        }
        vis[index]=1;
        for(j=1;j<=n;j++)
        {
            if(!vis[j]&&mp[index][j]+dis[index]<dis[j])//更新
            {
                dis[j]=mp[index][j]+dis[index];
            }
        }
    }
}
void over(int n)
{
    for(i=1;i<=n;i++)
    {
        for(j=i+1;j<=n;j++)
        {
            int temp=0;
            temp=mp[i][j];
            mp[i][j]=mp[j][i];
            mp[j][i]=temp;
        }
    }
}
void lujing(int n){
    for(i=1;i<=n;i++){
        dis[i]=mp[1][i];
    }
}

P1656 炸铁路

题目描述

思路

题意是求无向图的桥（割边），可以用 tarjan 算法

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 5e3+10,M = N*2;
int n,m;
int h[N],ne[M],e[M],idx;
int dfn[N],low[N],num,ans[M];
struct node
{
	int p,q;
}t[N];
bool cmp(node x,node y)
{
	if(x.p==y.p) return x.q<y.q;
	else return x.p<y.p;
}
void add(int a,int b)
{
	e[idx]=b,ne[idx]=h[a],h[a]=idx++; 
}
void tarjan(int x,int y)
{
	dfn[x]=low[x]=++num;
	for(int i=h[x];i!=-1;i=ne[i])
	{
		int u=e[i];
		if(!dfn[u])
		{
			tarjan(u,i);
			low[x]=min(low[x],low[u]);
			if(low[u]>dfn[x])
			ans[i]=ans[i^1]=1;
		}
		else if(i!=(y^1))
		low[x]=min(low[x],dfn[u]);
	}
}
int main()
{
	scanf("%d%d",&n,&m);
	memset(h,-1,sizeof(h));
	int a,b;
	idx=2;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d",&a,&b);
		add(a,b),add(b,a);
	}
	for(int i=1;i<=n;i++)
	{
		if(!dfn[i]) tarjan(i,0);
	}
	int k=0,x,y;
	for(int i=2;i<idx-1;i=i+2)
	{
		if(ans[i])
		{
			x=e[i],y=e[i^1];
			t[++k].p=min(x,y);
			t[k].q=max(x,y);
		}
	}
	sort(t+1,t+1+k,cmp);
	for(int i=1;i<=k;i++)
	{
		printf("%d %d\n",t[i].p,t[i].q);
	} 
	return 0;
 }

P1296 奶牛的耳语

题目描述

废话不多说代码如下：

#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[])
{
	int n, d;
	cin >> n >> d;
	vector<int> nums;
	int tmp;
	for(int i = 0; i < n; i++)
	{
		cin >> tmp;
		nums.push_back(tmp);
	}
	sort(nums.begin(), nums.end());
	int count = 0;
	int mymax = INT_MIN;
	for(int i = 0; i < nums.size(); i++)
	{
		for(int j = i + 1; j < nums.size(); j++)
		{
			if(nums[j] <= nums[i] + d)
			{
				count++;
			}
			else
				break;
		}
	}
	cout << count << endl;
	return 0;
}

关注

15
点赞
踩
22

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

随风佛 CSDN认证博客专家 CSDN认证企业博客

码龄1年

15: 原创

128万+: 周排名

21万+: 总排名

1万+: 访问

: 等级

429: 积分

212: 粉丝

279: 获赞

8: 评论

273: 收藏

私信

关注

热门文章

最新评论

每日学习录
CSDN-Ada助手: 恭喜你持续坚持每日学习并记录下来，这种坚持对于个人成长是非常有益的。希望你在未来的创作中可以尝试加入一些自己的思考和总结，这样不仅可以帮助自己更好地理解所学知识，也可以给读者带来更多启发和思考。期待看到你更多精彩的分享，加油！
每日学习录
CSDN-Ada助手: 恭喜您坚持每日学习并记录成果，这种持续的学习态度非常值得称赞。希望您能在以后的博客中，除了记录学习成果之外，还可以分享一些学习方法和心得体会，这样能够让更多的人受益。继续加油，期待您更多的精彩创作！
每日学习录（数据结构—排序）上
CSDN-Ada助手: 恭喜您第12篇博客的发布！每天学习都是很了不起的，尤其是数据结构中的排序部分，能够坚持学习并分享经验，真的很值得称赞。希望您在未来的学习中能够继续保持这样的学习态度，不断进步。下一步，我建议您可以尝试写一些实际应用场景下数据结构排序的案例分析，这样可以让读者更直观地理解到排序算法的实际应用价值。期待您更多的精彩内容！
每日学习录（数据结构—查找）下
CSDN-Ada助手: 恭喜您写了第11篇博客！每天学习都是一种难得的坚持，您的努力值得赞扬。阅读您关于数据结构中查找的文章，我深感受益匪浅。不过，在下认为您可以进一步深入探讨一些查找算法的实际应用场景，以及它们在不同情况下的性能优劣对比。希望这些建议能对您的下一篇博客有所帮助。期待您继续创作，分享更多有价值的学习内容！
每日学习录（数据结构—查找）（上）
CSDN-Ada助手: 恭喜您第十篇博客的发布！每日学习录系列一直都很受欢迎，尤其是涉及到数据结构的部分，对读者们来说是非常有帮助的。希望您能在下一篇博客中继续分享数据结构查找的知识，或者可以考虑结合一些实际案例，让读者更好地理解和运用这些知识。期待您的下一篇作品！

最新文章

目录

评论 1

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。