• 滑动窗口算法（C语言描述）

    第一种类型：不固定长窗口

    问题1：***

    C代码1：

    1. #include
    2. #include
    3. #define N 5
    4.  
    5. int min_len(int len1,int len2)
    6. {
    7. 	return (len1 < len2 ? len1:len2);
    8. }
    9.  
    10. int main()
    11. {
    12. 	int target = 0;
    13.     int num[N];
    14. 	scanf("%d",&target);
    15. 	for(int i = 0;i < N;i++)
    16. 	{
    17. 		scanf("%d",&num[i]);
    18. 	}
    19. 	
    20. 	
    21. 	//滑动窗口算法
    22. 	int left = 0;
    23. 	int right = 0;
    24. 	int sum = 0;
    25. 	int len = N+1;
    26. 	while(right < N)
    27. 	{
    28. 		sum += num[right];
    29. 		while(sum >= target)
    30. 		{
    31. 			sum -= num[left];
    32. 			if(sum < target)
    33. 			{
    34. 				len = min_len(len,right-left+1);
    35. 			}
    36.             left++;
    37. 		}
    38. 		right++;
    39. 	}
    40. 	if(len == N+1)
    41. 	{
    42. 		printf("No such subarray exists!");
    43. 	}
    44. 	else
    45. 	{
    46. 		printf("%d",len);
    47. 	}
    48. 	
    49. 	return 0;
    50. }

     问题2：*****

    C代码2： 

    1. #include
    2. #include
    3. #define N 80
    4.  
    5. //向窗口右边添加一个字符，拓宽窗口
    6. void Add_char(char ch,char *window)
    7. {
    8. 	int right = strlen(window);
    9. 	window[right] = ch;
    10. }
    11. //检查窗口字符串是否满足包含字符串t所有字符且数量不少于t
    12. int Is_ok(char *t,char *window)
    13. {
    14. 	int needs[128]={0};
    15. 	int windows[128]={0};
    16. 	int n=0;
    17. 	int w=0;
    18.     int len1 = strlen(window);
    19.     int len2 = strlen(t);
    20. 	for(int i=0;i
    21. 	{
    22. 		w = (int)window[i];
    23. 		windows[w]++;
    24. 	}
    25. 	for(int j=0;j
    26. 	{
    27. 		n = (int)t[j];
    28. 		needs[n]++;
    29. 	}
    30. 	for(int k = 0;k < 128;k++)
    31. 	{
    32. 		if(needs[k] != 0 && windows[k] < needs[k])
    33. 		{
    34. 			return 0;//不满足条件
    35. 		}
    36. 	}
    37. 	return 1;//满足条件
    38. }
    39.  
    40. /*判断当前满足条件的窗口字符串和满足条件的上一次结果字符串比较谁更短，并更新结果。
    41. 注意这里不要单纯的把指针result指向新结果（也就是窗口），因为窗口会随着循环而改变，
    42. 这样无法保留做中的正确结果，应该把结果字符串赋值给指针result指向的空间*/
    43. void minlen(char *result,char *window)
    44. {
    45. 	int result_len = strlen(result);
    46. 	int window_len = strlen(window);
    47. 	if(result_len > window_len)
    48.     {
    49.         for(int i = 0;i <= window_len;i++)
    50.         {
    51.             result[i] = window[i];
    52.         }
    53.     }
    54. }
    55.  
    56. //移除窗口左边第1个字符
    57. void remove_char(char *window)
    58. {
    59.     int len = strlen(window);
    60. 	for(int i= 0;i < len;i++)
    61. 	{
    62. 		window[i] = window[i+1];
    63. 	}
    64. }
    65.  
    66. int main()
    67. {
    68. 	//定义所需字符数组
    69. 	char s[N];//存储字符串s
    70. 	char t[N];//存储字符串t
    71. 	char window[N]={'\0'};//窗口内的字符串
    72. 	char *result = s;//存储找到的满足条件的最短字符串，这里初始化时将其指向字符串s
    73. 	
    74. 	//输入字符串s和t
    75. 	scanf("%s",s);
    76. 	scanf("%s",t);
    77. 	
    78. 	//定义滑动窗口所需变量
    79. 	int left = 0;//窗口左边界指针
    80. 	int right = 0;//窗口右边界指针
    81. 	int end = strlen(s);//字符串s的长度，窗口滑动的终止点
    82. 	//开始滑动窗口寻找满足条件的最短字符串
    83.     int flag = 0;
    84. 	while(right < end)
    85. 	{
    86. 		Add_char(s[right],window);//拓宽窗口右边界
    87. 		while(Is_ok(t,window)&&left < end)//窗口满足条件，已包含字符串t所有字符且数量也不少
    88. 		{
    89.             flag = 1;
    90. 			minlen(result,window);//更新最短满足条件子串答案
    91.             remove_char(window);//移除窗口左边第1个字符
    92. 			left++;//窗口左边界边界向前滑动
    93. 		}
    94. 		right++;
    95. 	}
    96.     if(flag)
    97.     {
    98.         printf("%s\n",result);
    99.     }
    100.     else
    101.     {
    102.         printf("No such string!\n");
    103.     }
    104. 	return 0;
    105. }

    问题3：

    C代码3：

    (代码版本1）和上面一个题目差不多，只不过在这里更新答案要加点条件。

    1. #include
    2. #include
    3.  
    4. //向窗口右边添加一个字符，拓宽窗口
    5. void add_char(int right,char *s,char *window)
    6. {
    7. 	int len = strlen(window);
    8. 	window[len] = s[right];
    9. }
    10.  
    11. //检查窗口字符串是否满足包含字符串t所有字符且数量不少于t
    12. int Is_ok(char *window,char *p)
    13. {
    14. 	int len_w = strlen(window);
    15. 	int len_p = strlen(p);
    16.  
    17. 	int windows[128]={0};
    18. 	int ps[128]={0};
    19. 	
    20. 	int t=0;
    21. 	for(int i = 0;i
    22. 	{
    23. 		t = (int)window[i];
    24. 		windows[t]++;
    25. 	}
    26. 	for(int j = 0;j
    27. 	{
    28. 		t = (int)p[j];
    29. 		ps[t]++;
    30. 	}
    31. 	for(int k = 0;k<128;k++)
    32. 	{
    33. 		if(ps[k] != 0&& ps[k] > windows[k])
    34. 		{
    35. 			return 0;
    36. 		}
    37. 	}
    38. 	return 1;
    39.  
    40. }
    41.  
    42. //移除窗口左边第1个字符
    43. void remove_char(char *window)
    44. {
    45. 	int len_w = strlen(window);
    46. 	for(int i=0;i
    47. 	{
    48. 		window[i] = window[i+1];
    49. 	}
    50. 	
    51. }
    52. int main()
    53. {
    54. 	//定义字符数组
    55. 	char s[20101]={'\0'};
    56. 	char p[20101]={'\0'};
    57. 	char win[20101]={'\0'};
    58. 	//输入字符串s和p
    59. 	scanf("%s",s);
    60. 	scanf("%s",p);
    61. 	//滑动窗口求解答案
    62. 	int left = 0;
    63.     int right = 0;
    64.     char *window = win;
    65.     int end = strlen(s);
    66.     
    67. 	int flag = 0;//检查s中满足条件的子字符串是否大于0
    68. 	int index_arr[1000]={0};
    69. 	int x = 0;
    70.     while(right < end)
    71.     {
    72.     	add_char(right,s,window);
    73.     	while(Is_ok(window,p)&&left < end)字符串是异位字符串的前提1是两字符字符种类数量一样
    74.     	{
    75.     		int len1 = strlen(window);
    76. 			int len2 = strlen(p);
    77. 			if(len1==len2) //字符串是异位字符串的前提2是两字符字符长度一样
    78. 			{
    79. 				int flag2 = 0;
    80. 				for(int j=0;j
    81. 				{
    82. 					if(window[j] != p[j])//字符串是异位字符串的必要条件是两字符字符不能一模一样
    83. 					{
    84. 						flag2 = 1;
    85. 					}
    86. 				}
    87. 				if(flag2)
    88. 				{
    89. 					index_arr[x] = left;
    90. 					x++;
    91. 					flag = 1;
    92. 				}
    93. 				
    94. 			}
    95. 			remove_char(window);
    96.     		left++;
    97.     	}
    98.     	right++;
    99.     }
    100.     
    101.     if(flag)
    102.     {
    103.     	for(int i=0;i
    104.     	{
    105.     		if(i != x-1)
    106.     		{
    107.     			printf("%d ",index_arr[i]);
    108.     		}
    109.     		else
    110.     		{
    111.     			printf("%d\n",index_arr[i]);
    112.     		}
    113.     	}
    114.     }
    115.     else
    116.     {
    117.     	printf("没有这样匹配的字符串！\n");
    118.     }
    119. 	return 0;	
    120. }

    代码版本2：

    1. #include
    2. #include
    3.  
    4. // 判断字符串s的子串（from left to right）是否包含p的所有字符，并且个数满足要求
    5. int judge_str(int list[],int left,int right, char s[])
    6. {
    7. 	int win[128] = { 0 };
    8. 	for (int i = left; i <= right; i++)        
    9. 	{
    10. 		int index = s[i];
    11. 		win[index]++;
    12. 	}
    13.  
    14. 	for (int i = 0; i < 128; i++)
    15. 	{
    16. 		if (list[i] != 0 && list[i] > win[i])
    17. 		{
    18. 			return 0; // 有字符不满足条件，则本子串不满足条件，返回0
    19. 		}
    20. 	}
    21. 	return 1; // 所有字符均满足条件，则本子串满足条件，返回1
    22. }
    23.  
    24.  
    25. // 比较s子串（from left to right）与p是否异位，如果异位返回1，否则返回0
    26. int compare_str(char s[],char p[],int left,int right)
    27. {
    28. 	for(int i = left,t = 0;i <= right;i++,t++)
    29. 	{
    30. 		if(s[i] != p[t])
    31. 		{
    32. 			return 1; // s子串与p存在不同字符 ，那么他们是异位词，返回1
    33. 		}
    34. 	}
    35. 	return 0; // s子串与p全都一样，返回0
    36. }
    37.  
    38. // 方案主函数，遍历s搜索所有符合条件的子串，将其开始位置存入 position 数组中，并返回是否找到符合条件的子串
    39. int move_window(char s[],char p[], int list[], int size, int position[])
    40. {
    41. 	int left = 0;
    42. 	int right = size - 1;
    43. 	int end = strlen(s) - 1;
    44. 	int count = 0;
    45. 	int flag = 0;
    46.  
    47. 	while (right <= end &&left <= end && left < right)
    48. 	{
    49. 		// 判断当前窗口是否满足条件：包含所有p的字符且数量一样
    50. 		if(judge_str(list,left,right,s))
    51. 		{
    52. 			// 如果满足，并且s子串与p是异位词，那么当前窗口符合条件
    53. 			if(compare_str(s,p,left,right))
    54. 			{
    55. 				flag = 1;
    56. 				position[count] = left;
    57. 				count++;
    58. 			}
    59. 		}
    60. 		// 滑动窗口，准备扫描下个子串
    61. 		right++;
    62. 		left++;
    63. 	}
    64. 	position[20101] = count; // 用数组特殊位置存储合适子串个数
    65.  
    66. 	return flag; // 返回是否存在满足条件的子串
    67. }
    68.  
    69.  
    70. // 程序的主入口
    71. int main()
    72. {
    73. 	// 输入字符串
    74. 	char s[20101] = { '\0' };
    75. 	char p[20101] = { '\0' };
    76. 	int position[20101] = { -1 };
    77.  
    78. 	scanf("%s", s);
    79. 	scanf("%s", p);
    80.  
    81. 	// 限制窗口宽度
    82. 	int size = strlen(p);
    83. 	// 创造p的哈希表，用于后续快速判断子串是否包含所有p的字符
    84. 	int list[128] = { 0 };
    85. 	for (int i = 0; i < size; i++)
    86. 	{
    87. 		int index = p[i];
    88. 		list[index]++;
    89. 	}
    90.  
    91. 	// 寻找符合条件的子串，并返回其开始位置
    92. 	int flag = move_window(s,p, list, size, position);
    93.  
    94. 	// 输出结果
    95. 	if (flag) // 如果存在满足条件的子串
    96. 	{
    97. 		int count = position[20101]; // 获取满足条件的子串数量
    98. 		printf("count = %d\n",count);
    99. 		printf("[");
    100. 		for (int i = 0; i < count; i++)
    101. 		{
    102. 			if (i != count - 1)
    103. 			{
    104. 				printf("%d, ", position[i]);
    105. 			}
    106. 			else
    107. 			{
    108. 				printf("%d]\n", position[i]);
    109. 			}
    110. 		}
    111. 	}
    112. 	else // 如果不存在满足条件的子串
    113. 	{
    114. 		printf("没有这样的子串！\n");
    115. 	}
    116. 	return 0;
    117. }

    问题4：

    C代码4：

    和前面有一点不一样，主要是窗口移动不太一样。

    1. #include
    2. #include
    3. #define N 80
    4.  
    5. //向窗口右边添加一个字符，拓宽窗口
    6. void Add_char(char ch,char *window)
    7. {
    8. 	int right = strlen(window);
    9. 	window[right] = ch;
    10. }
    11. //检查窗口字符串是否满足包含字符串t所有字符且数量不少于t
    12. int Is_ok(char *window)
    13. {
    14. 	int windows[128]={0};
    15. 	int w=0;
    16.     int len1 = strlen(window);
    17. 	for(int i=0;i
    18. 	{
    19. 		w = (int)window[i];
    20. 		windows[w]++;
    21. 	}
    22. 	for(int k = 0;k < 128;k++)
    23. 	{
    24. 		if(windows[k] > 1)
    25. 		{
    26. 			return 0;//不满足条件
    27. 		}
    28. 	}
    29. 	return 1;//满足条件
    30. }
    31.  
    32. /*判断当前满足条件的窗口字符串和满足条件的上一次结果字符串比较谁更短，并更新结果。
    33. 注意这里不要单纯的把指针result指向新结果（也就是窗口），因为窗口会随着循环而改变，
    34. 这样无法保留做中的正确结果，应该把结果字符串赋值给指针result指向的空间*/
    35. void maxlen(char *result,char *window)
    36. {
    37. 	int result_len = strlen(result);
    38. 	int window_len = strlen(window);
    39. 	if(result_len < window_len)
    40.     {
    41.         for(int i = 0;i <= window_len;i++)
    42.         {
    43.             result[i] = window[i];
    44.         }
    45.     }
    46. }
    47.  
    48. //移除窗口左边第1个字符
    49. void remove_char(char *window)
    50. {
    51.     int len = strlen(window);
    52. 	for(int i= 0;i < len;i++)
    53. 	{
    54. 		window[i] = window[i+1];
    55. 	}
    56. }
    57.  
    58. int main()
    59. {
    60. 	//定义所需字符数组
    61. 	char s[N];//存储字符串s
    62. 	char window[N]={'\0'};//窗口内的字符串
    63. 	char result[N]={'\0'};//存储找到的满足条件的最短字符串，这里初始化时将其指向字符串s
    64. 	
    65. 	//输入字符串s和t
    66. 	scanf("%s",s);
    67. 	
    68. 	//定义滑动窗口所需变量
    69. 	int left = 0;//窗口左边界指针
    70. 	int right = 0;//窗口右边界指针
    71. 	int end = strlen(s);//字符串s的长度，窗口滑动的终止点
    72. 	//开始滑动窗口寻找满足条件的最短字符串
    73.     int flag = 0;
    74. 	while(right < end)
    75. 	{
    76. 		Add_char(s[right],window);//拓宽窗口右边界
    77. 		if(Is_ok(window)&&left < end)//窗口满足条件，已包含字符串t所有字符且数量也不少
    78. 		{
    79.             flag = 1;
    80. 			maxlen(result,window);//更新最短满足条件子串答案
    81.         }
    82.         else
    83.         {
    84.         	remove_char(window);//移除窗口左边第1个字符
    85. 			left++;//窗口左边界边界向前滑动
    86. 		}
    87. 		right++;
    88. 	}
    89. 	
    90.     if(flag)
    91.     {
    92.         printf("%d\n",strlen(result));
    93.     }
    94.     else
    95.     {
    96.         printf("No such string!\n");
    97.     }
    98.     
    99. 	return 0;
    100. }

  • 相关阅读:
    Linux CentOS 7升级curl8.4.0使用编译安装方式
    nginx降权及匹配php
    vivo 在离线混部探索与实践
    WebSocket基础——WebSocket的基本概念 VS Http & SpringBoot整合WebSocket & vue前端代码和效果展示
    在 Node.js 中发出 HTTP 请求的 5 种方法
    有哪些好用的性能测试工具推荐?性能测试报告收费标准
    前端html实现带行号的文本编辑器
    【Linux专题】firewalld 过滤出接口流量
    熊市下PLATO如何通过Elephant Swap，获得溢价收益？
    每日一博 - 浅析事务隔离级别& MVCC机制
  • 原文地址：https://blog.csdn.net/2303_76295261/article/details/133692064