Day53 日志统计（滑动窗口） bfs flood fill算法

最新推荐文章于 2024-07-12 15:26:27 发布
最新推荐文章于 2024-07-12 15:26:27 发布
阅读量182 收藏
点赞数
分类专栏： 日更学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43982216/article/details/107121106
版权

日志统计
显然这题用滑动窗口
然后一开始想着滑动窗口就是队列嘛
然后一直想着队列
殊不知可以直接用cnt记录id个数
然后直接用cnt完成滑动
每一个日志条目都完成一次入队，多次出队
每一次入队多次出队完就判断赞数目是否达到

以st做热帖的标记

我一开始还想用set

#include<vector>
#include<cstring>
#include<cstdio>
#include<iostream>
#include<string>
#include<map>
#include<queue>
#include<algorithm>
#include<set> 
#include<ctime>
#include<cmath>
#include<cstdlib>
#define lson (o<<1)
#define rson (o<<1|1)
#define fi first
#define sc second
#define dbg(x) cout<<#x<<" = "<<(x)<<endl;
#define rg register
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
using namespace std;
const double pi=acos(-1);
const double eps=1e-6;
inline int lowbit(int x){return x&(-x);}

template<typename A,typename B,typename C> inline A fpow(A x,B p,C yql){
	A ans=1;
	for(;p;p>>=1,x=1LL*x*x%yql)if(p&1)ans=1LL*x*ans%yql;
	return ans;
}


inline int read()
{
    int X=0,w=1;
    char c=getchar();
    while(c<'0'||c>'9')
    {
        if (c=='-')
        {
            w=-1;
        }
        c=getchar();
    }
    while(c>='0'&&c<='9')
    {
        X=(X<<3)+(X<<1)+(c^48);
        c=getchar();
    }
    return X*w;
}
//inline void w(int x) { if(x>9) w(x/10); putchar(x%10+'0'); }
const int N=1e5+10; 
ll T;
bool st[N];
int cnt[N];
pair<int,int>tex[N];
void solve(){
	int n,d,k;
	cin>>n>>d>>k;
	int tx,id;
	for(int i=0;i<n;i++){
		cin>>tex[i].first>>tex[i].second;
	}
	sort(tex,tex+n);
	for(int i=0,j=0;i<n;i++){
		id=tex[i].second;
		cnt[id]++;
		while(tex[i].first-tex[j].first>=d){
			cnt[tex[j].second]--;
			j++;
		}
		if(cnt[id]>=k){
			st[id]=1;
		}
	}
	for(int i=0;i<=100000;i++){
		if(st[i]){
			cout<<i<<endl;
		}
	}	
}


int main(){
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);
	T=1;
	//cin>>T;
	while(T--){
		solve();
	}
	return 0;
}

献给阿尔吉侬的花束
我用的是结构体里存储时间
y总是用了dist数组
我觉得我的更好写一些

#include<vector>
#include<cstring>
#include<cstdio>
#include<iostream>
#include<string>
#include<map>
#include<queue>
#include<algorithm>
#include<ctime>
#include<cmath>
#include<cstdlib>
#define lson (o<<1)
#define rson (o<<1|1)
#define fi first
#define sc second
#define dbg(x) cout<<#x<<" = "<<(x)<<endl;
#define rg register
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
using namespace std;
const double pi=acos(-1);
const double eps=1e-6;
inline int lowbit(int x){return x&(-x);}

template<typename A,typename B,typename C> inline A fpow(A x,B p,C yql){
	A ans=1;
	for(;p;p>>=1,x=1LL*x*x%yql)if(p&1)ans=1LL*x*ans%yql;
	return ans;
}


inline int read()
{
    int X=0,w=1;
    char c=getchar();
    while(c<'0'||c>'9')
    {
        if (c=='-')
        {
            w=-1;
        }
        c=getchar();
    }
    while(c>='0'&&c<='9')
    {
        X=(X<<3)+(X<<1)+(c^48);
        c=getchar();
    }
    return X*w;
}
//inline void w(int x) { if(x>9) w(x/10); putchar(x%10+'0'); }
const int N=210;
#define PII pair<int,int>
ll T;
char maze[N][N];
int sx,sy,ex,ey;

struct node{
	int x,y,t;
};
int dx[]={0,0,-1,1},dy[]={1,-1,0,0};
int n,m;
bool vis[N][N];
int bfs(){
	memset(vis,0,sizeof(vis));
	queue<node>q;
	q.push({sx,sy,0});
	
	while(q.size()){
		node now=q.front();
		if(now.x==ex&&now.y==ey){
			cout<<now.t<<endl;
			return 1;
		}
		q.pop();
		for(int i=0;i<4;i++){
			int tx=now.x+dx[i],ty=now.y+dy[i];
			if(!vis[tx][ty]&&tx>=0&&tx<n&&ty>=0&&ty<m&&maze[tx][ty]!='#'){
				vis[tx][ty]=1;
				q.push({tx,ty,now.t+1});
			}
		}
	}
	return 0;
}

void solve(){

	cin>>n>>m;
	
	for(int i=0;i<n;i++)cin>>maze[i];
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			if(maze[i][j]=='S'){
				sx=i,sy=j;
			}
			if(maze[i][j]=='E'){
				ex=i,ey=j;
			}
		}
	}
	if(!bfs())
	cout<<"oop!"<<endl;
	
}


int main(){
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);
	//T=1;
	cin>>T;
	while(T--){
		solve();
	}
	return 0;
}

红与黑
bfs写法

#include<vector>
#include<cstring>
#include<cstdio>
#include<iostream>
#include<string>
#include<map>
#include<queue>
#include<algorithm>
#include<ctime>
#include<cmath>
#include<cstdlib>
#define lson (o<<1)
#define rson (o<<1|1)
#define fi first
#define sc second
#define dbg(x) cout<<#x<<" = "<<(x)<<endl;
#define rg register
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
using namespace std;
const double pi=acos(-1);
const double eps=1e-6;
inline int lowbit(int x){return x&(-x);}

template<typename A,typename B,typename C> inline A fpow(A x,B p,C yql){
	A ans=1;
	for(;p;p>>=1,x=1LL*x*x%yql)if(p&1)ans=1LL*x*ans%yql;
	return ans;
}


inline int read()
{
    int X=0,w=1;
    char c=getchar();
    while(c<'0'||c>'9')
    {
        if (c=='-')
        {
            w=-1;
        }
        c=getchar();
    }
    while(c>='0'&&c<='9')
    {
        X=(X<<3)+(X<<1)+(c^48);
        c=getchar();
    }
    return X*w;
}
//inline void w(int x) { if(x>9) w(x/10); putchar(x%10+'0'); }
#define PII pair<int,int>
#define N 30
ll T;
int n,m;
int ans=0,dx[]={0,0,-1,1},dy[]={1,-1,0,0};
bool vis[N][N];
char maze[N][N]; 
int bfs(int x,int y){
	queue<PII>q;
	q.push({x,y});
	vis[x][y]=1;
	ans=1;
	while(!q.empty()){
		PII now=q.front();
		q.pop();
		
		for(int i=0;i<4;i++){
			int tx=now.first+dx[i],ty=now.second+dy[i];
			if(tx>=0&&tx<n&&ty>=0&&ty<m&&!vis[tx][ty]&&maze[tx][ty]!='#'){
				vis[tx][ty]=1;
				q.push({tx,ty});
				ans++;
			}
		}
	}
}

void solve(){
	for(int i=0;i<n;i++){
		cin>>maze[i];
	}
	int sx,sy;
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			if(maze[i][j]=='@'){
				sx=i,sy=j;
			}
		}
	}
	memset(vis,0,sizeof(vis));
	bfs(sx,sy);
	cout<<ans<<endl;

}


int main(){
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);
	//T=1;
	//cin>>T;
	while(cin>>m>>n){
		if(m==0&&n==0)break;
		solve();
	}
	return 0;
}

dfs写法

#include<vector>
#include<cstring>
#include<cstdio>
#include<iostream>
#include<string>
#include<map>
#include<queue>
#include<algorithm>
#include<ctime>
#include<cmath>
#include<cstdlib>
#define lson (o<<1)
#define rson (o<<1|1)
#define fi first
#define sc second
#define dbg(x) cout<<#x<<" = "<<(x)<<endl;
#define rg register
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
using namespace std;
const double pi=acos(-1);
const double eps=1e-6;
inline int lowbit(int x){return x&(-x);}

template<typename A,typename B,typename C> inline A fpow(A x,B p,C yql){
	A ans=1;
	for(;p;p>>=1,x=1LL*x*x%yql)if(p&1)ans=1LL*x*ans%yql;
	return ans;
}


inline int read()
{
    int X=0,w=1;
    char c=getchar();
    while(c<'0'||c>'9')
    {
        if (c=='-')
        {
            w=-1;
        }
        c=getchar();
    }
    while(c>='0'&&c<='9')
    {
        X=(X<<3)+(X<<1)+(c^48);
        c=getchar();
    }
    return X*w;
}
//inline void w(int x) { if(x>9) w(x/10); putchar(x%10+'0'); }
const int N=30;
ll T;
char maze[N][N];
int n,m;
int sx,sy,ans=0,dx[]={0,0,1,-1},dy[]={1,-1,0,0};
bool vis[N][N];
int dfs(int x,int y){
	int cnt=1;
	vis[x][y]=1;
	for(int i=0;i<4;i++){
		int tx=dx[i]+x,ty=dy[i]+y;
		if(!vis[tx][ty]&&tx>=0&&tx<n&&ty>=0&&ty<m&&maze[tx][ty]!='#'){
			cnt+=dfs(tx,ty);
		}
	}
	return cnt;
}

void solve(){
	for(int i=0;i<n;i++){
		cin>>maze[i];
	}
	
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			if(maze[i][j]=='@'){
				sx=i,sy=j;
			}
		}
	}
	memset(vis,0,sizeof(vis));

	ans=0;
	cout<<dfs(sx,sy)<<endl;

}


int main(){
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);
	T=1;
	//cin>>T;
	while(cin>>m>>n){
		if(m==0&&n==0){
			break;
		}
		solve();
	}
	return 0;
}
离开那天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
日志分析系统（滑动窗口及缓冲区的应用）
Oliver______的博客
08-15 471
好几天都忙着在写一个日志分析系统，除了这个什么也没做，感觉自己什么也没学到，但是做完后回头一看，又发现收获颇丰，可能就是对实际做东西的能力得到了稍微的提升吧。 先上代码。 #!/usr/bin/python3 import re import datetime import logging import json from functools import wraps d=dict() dargs...
【算法学习日志】滑动窗口解决最长不重复子串问题
weixin_43994069的博客
08-21 283
Java里使用HashMap类就不戳。 在这之前先回顾一下哈希表：将数据映射到数组中对应的位置。 解决哈希冲突： 线性寻址 拉链 线性寻址就是说如果某个数据经过散列函数以后，它对应的位置已经被占用了，那么就顺着往下找第一个没有被占用的位置存放它。缺点在于删除需要设置一个删除标记位，免得查找出错；冲突过多的时候哈希查找可能会变成跟遍历差不多。 拉链法遍历慢。 JDK1.7解决哈希冲突就是使用的拉链。 JDK1.8以后引入了红黑树，在链表>8时使用红黑树。 然后看几个HashMap提供..
算法日志
CAXWin的博客
09-20 183
题目：给定一组正整数数组A与一个正整数K，求整数数组A中和为K的子序列个数： 例如输入[1,1,1] 输出 2 def countSumK(A,K): count = collections.Counter() rs = 0 count[0] = 1 sub_Sum = 0 for i in range(len(A)): sub_Sum += A[i] rs += count[sub_Sum - ...
Sentinel限流算法：滑动时间窗算法、漏桶算法、令牌桶算法。拦截器定义资源实现原理
最新发布
qq_44027353的博客
07-12 1240
‌例如，‌可以使用一个环形数组来存储时间窗口内的数据点，‌数组的大小等于时间窗口的大小（‌以时间单位为单位）‌。‌每当有新的数据点进入时，‌旧的对应时间点的数据将被覆盖，‌从而实现滑动时间窗的效果。而且，当桶满了之后，多余的水将会溢出。‌随着时间的推移，‌新的数据点进入窗口，‌而旧的数据点则被移出窗口，‌从而形成了一个滑动的时间窗口。我们引入了下面的依赖，也就是我们实际使用sentinel的场景下，我们会发现我们controller层编写的http请求接口都不需要我们自己额外的定义资源开启保护。
【蓝桥】日志统计（滑动窗口）
sdd11221的博客
06-03 133
//完全就是coding能力 #include<bits/stdc++.h> using namespace std; const int n=1e5+10; int N,D,K;//日志条数，， vector<int> v[n];//编号作为下标 vector<int> hot;//存入热帖编号 int ts,id;//时刻，帖子编号 int sz;//某个帖子出现的次数 int main() { cin>>N>>D>>K;
蓝桥杯算法心得——日志统计（滑动窗口）
晴天学长
04-07 326
1.滑动窗口（注意窗口大小和移动中数组元素的变化）滑动窗口的初始化滑动窗口的移动2.要是有编号而且还是有顺序的话，直接用数组的下标作为编号，然后统计。
BFS算法BFS算法BFS算法BFS算法
08-30
根据给定文件的信息，我们可以提炼出关于BFS（广度优先搜索）算法的重要知识点，并结合描述部分提及的决策树概念进行深入分析。 ### BFS算法概述 BFS算法是一种用于图的查找算法，常用于解决两类问题： 1. **路径...
BFS.zip_Bfs算法_图BFS算法
09-19
**BFS算法详解** 在计算机科学中，图遍历是一种重要的算法，用于探索图的所有节点。其中，广度优先搜索（Breadth-First Search，简称BFS）是一种按照节点的层次顺序遍历图的方法。BFS算法尤其适用于寻找最短路径、...
Flood_Fill算法
05-25
广度优先搜索（BFS）是 Flood Fill 算法的一种实现方式。它的实现方式是把结点加入队列中，然后对队列中的每个结点进行扩展，直到队列为空。广搜稍微好一点，不过也存在问题。搜索大的图它的队列有可能存不下。 ...
bfs.rar_Bfs算法_bfs
09-20
宽度优先搜索（BFS，Breadth-First Search）是一种用于遍历或搜索树或图的算法，它从根节点开始，沿着树的宽度方向进行探索，直到找到目标节点或者遍历完整个树。在图中，BFS通常用于找出两个节点间的最短路径，或者...
啊哈算法哈磊第五节宝岛探险统计岛屿面积BFS算法(java)
06-08
本资源聚焦于《啊哈算法》第五章节的核心内容——“宝岛探险：统计岛屿面积”，通过Java语言实战展示了如何运用BFS（广度优先搜索）算法来解决这一经典问题。在这个资源中，你将深入了解到如何在二维网格图中识别并...
详细述说日志滑动窗口生成步骤
weixin_35756624的博客
02-17 120
日志滑动窗口生成步骤包括：1、选择要处理的日志文件；2、确定要使用的滑动窗口大小；3、定义数据结构，用于存储滑动窗口；4、从日志文件中按行读取数据；5、把每一行的数据添加到滑动窗口中；6、当滑动窗口满足给定的条件时，输出滑动窗口中的内容；7、重复以上步骤，直到处理完整个日志文件。 ...
清理脚本滑动窗口方式清理日志文件
cloudusers的专栏
11-29 1073
程序一般都会生成日志文件，同时也有一个对应的清理脚本， 大部分清理脚本都就是crontab中定时启动 但如果每分钟一个日志文件，然后需要保持一分钟的滑动窗口进行清理应该怎么办呢？ 我测试的清理脚本如下示： cat clear.sh #!/bin/sh date=$(date -v -1d +%Y-%m-%d) root=/rootpath/ input=$root/data
sentinel-滑动时间窗口算法探索
随笔
02-10 1050
简介 其实sentinel核心原理并不难理解，就是在访问被保护资源时，根据实时的统计信息和预先定义的规则，检查是否可以访问。对我自己而言，可能统计的算法是比较关心的，都知道sentinel的统计算法是滑动时间窗口算法，这个算法一这么说就不接地气了，下面谈谈我们农村的说法。 探索 说这个算法主要要解决什么事呢？就是说在某个时间间隔要做点统计，比如说现在时间是16:06:21,320，我现在想知道16:06:21,000-16:06:21,320我的应用app通过了多少个请求，即当前的32...
日志统计问题（ 错误示范 + 双指针 + 滑动窗口 ）
2302_77698668的博客
09-13 155
很多小伙伴在练习算法题目的时候经常碰上这样一类题目，给出n个ts , id表示在某时刻对某id进行了某某操作，但随着时间的流逝，该操作带来的影响会逐步消退，让我们统计在某个区间段内达到要求的id这里还可以看往期的类似文章外卖优先级问题:希望小伙伴们吸取到我错误示范中的教训，滑动窗口对数组更新时带来的影响在实现上面要慎重，以及学会如何构建滑动窗口以及更新滑动窗口。
日志统计
qq_45832461的博客
03-26 309
日志统计 题目描述 核心思路 典型的固定大小窗口问题，只需要用双指针移动即可。把所有日志按照时间先后顺序排序，然后利用双指针法，维护一个长度为D但是窗口的大小应该是D-1(因为是左闭右开)的区间，当存在点赞数大于等于 K 的帖子时，就将它记录下来。i指针在前面跑，j指针在后面追。如果j指针所指向的内容以及划出了窗口，则将左指针所指向的id帖子的点赞取消，然后让j指针指向下一个，之后再右移i指针，再将当前右指针所指时刻被点赞的帖子id加上相应的点赞。 我们用一个数组cnt来用来记录一个id号获得的赞数。当
日志统计（滑动窗口二刷）
厚积而薄发
03-17 215
文章目录QuestionIdeasCode Question 小明维护着一个程序员论坛。现在他收集了一份”点赞”日志，日志共有 N 行。 其中每一行的格式是： ts id 表示在 ts 时刻编号 id 的帖子收到一个”赞”。 现在小明想统计有哪些帖子曾经是”热帖”。 如果一个帖子曾在任意一个长度为 D 的时间段内收到不少于 K 个赞，小明就认为这个帖子曾是”热帖”。 具体来说，如果存在某个时刻 T 满足该帖在 [T,T+D) 这段时间内(注意是左闭右开区间)收到不少于 K 个赞，该帖就曾是”热帖”。 给定日
[蓝桥杯2018初赛]日志统计。 所用算法：双指针算法
菜瓜变菜鸟
07-10 297
1373: [蓝桥杯2018初赛]日志统计 <—做题链接 1373: [蓝桥杯2018初赛]日志统计 时间限制: 1 Sec 内存限制: 256 MB 提交: 249 解决: 73 [状态] [提交] [命题人:外部导入] 题目描述 小明维护着一个程序员论坛。现在他收集了一份"点赞"日志，日志共有N行。 其中每一行的格式是：ts id。表示在ts时刻编号id的帖子收到一个"赞"。 现在小明想统计有哪些帖子曾经是"热帖"。 如果一个帖子曾在任意一个长度为D的时间段内收到不少于K个赞，小明
BFS算法详解与应用示例
"这篇资料主要介绍了BFS（广度优先搜索）算法，是关于搜索策略在ACM/ICPC竞赛中的应用。文档首先概述了搜索算法在算法和人工智能中的重要性，同时也指出了其学习和使用的挑战。接着，区分了盲目搜索和启发式搜索两种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值