最短完备子序列——包含T全部元素的最小子窗口

、、、、、、

#include <iostream>
#include <map>
#include <queue>
#include <climits>
#include <algorithm>
#include <string>
using namespace std;

bool MinWindow(vector<int> s, vector<int> t, int &startWin, int &endWin) {
	int slen = s.size();
	int tlen = t.size();
	if (slen <= 0 || tlen <= 0) {
		return false;
	}
	// 存储T中不同字符的总数
	int needFind[256] = { 0 };
	for (int i = 0; i < tlen; ++i) {
		++needFind[t[i]];
	}
	// 不在T中的元素设置为-1
	for (int i = 0; i < 256; ++i) {
		if (needFind[i] == 0) {
			needFind[i] = -1;
		}
	}
	int minWinLen = INT_MAX;
	// 队列数组,每个不同的字符都对应一个队列
	queue<int> q[256];
	// 第一个元素和最后一个元素表明了窗口的开始和结束位置
	map<int, char> m;
	int val;
	for (int i = 0; i < slen; ++i) {
		val = s[i];
		// 跳过不在T中的元素
		if (needFind[val] == -1) {
			continue;
		}
		// 字符放入队列
		if (q[val].size() < needFind[val]) {
			q[val].push(i);
			m[i] = val;
		}
		// 取代队列中的字符,更新map中对应元素
		else {
			int idxToErase = q[val].front();
			map<int, char>::iterator it = m.find(idxToErase);
			m.erase(it);
			m[i] = val;
			q[val].pop();
			q[val].push(i);
		}
		if (m.size() == tlen) {
			int end = m.rbegin()->first;
			int start = m.begin()->first;
			int winLen = end - start + 1;
			if (winLen < minWinLen) {
				minWinLen = winLen;
				startWin = start;
				endWin = end;
			}
		}
	}
	return (m.size() == tlen);
}

int main() {
	int N, M;
	int data;
	vector<int> s;
	vector<int> t;
	while (cin >> N >> M) {
		for (int i = 0; i < N; i++) {
			cin >> data;
			s.push_back(data);
		}
		for (int i = 1; i <= M; i++) {
			t.push_back(i);
		}
		int start, end;
		bool result = MinWindow(s, t, start, end);
		if (result) {
			cout << end - start + 1 << endl;
		}
		else {
			cout << 0 << endl;
		}
	}
	return 0;
}

 

 

 

转自: https://blog.csdn.net/yangwenxue_admin/article/details/44568069

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
迪杰斯特拉算法(Dijkstra)是一种贪心算法,用于解决最短路径问题。它可以处理有权有向图或无向图,但不允许有负权边(权重必须为非负数)。 算法思路: 1. 从起点开始,初始化所有节点的距离为无穷大,起点距离为0; 2. 将起点加入“已访问”集合; 3. 对于起点的所有邻居节点,更新它们的距离(如果通过当前节点到达邻居节点的距离小于邻居节点原有的距离,则更新邻居节点的距离); 4. 从未访问集合选择距离起点最近的节点,加入“已访问”集合; 5. 重复步骤3和4,直到所有节点都被加入“已访问”集合或者没有与起点相连的节点。 算法实现: Dijkstra算法的实现通常使用优先队列(PriorityQueue)来维护未访问集合距离起点最近的节点。具体实现步骤如下: 1. 创建一个空的优先队列Q,将起点加入Q,并设置起点到自身的距离为0; 2. 创建一个数组dist[],用于保存起点到各个节点的距离,初始化为无穷大; 3. 创建一个数组visited[],用于标记节点是否被访问过,初始化为false; 4. 将dist[起点]的值设置为0; 5. 当Q不为空时,重复以下步骤: a. 从Q取出距离起点最近的节点u; b. 如果节点u已经被访问过,则跳过此次循环; c. 将节点u标记为已访问; d. 对于节点u的每个邻居节点v,如果节点v未被访问过并且通过节点u到达节点v的距离小于dist[v],则更新dist[v]的值; e. 将节点v加入Q。 6. 最终,dist数组保存的就是起点到各个节点的最短距离。 Dijkstra算法的时间复杂度为O(ElogV),其E为边数,V为节点数。这是因为算法需要对每个节点的所有邻居节点进行遍历,而优先队列的插入和删除操作的时间复杂度为O(logV)。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值