floyd进阶,最大频率栈，反向链表，kthsmallest

1.floyd进阶

题目:Problem - 1196F - Codeforces

题目大意:在一张有向图中，找出两点之间距离第k小.

思路分析:(注意开long long)

1.先根据各顶点距离对各顶点排序 

2.建图 标号

3.floyd求出距离 取min(k,m)来算

4.sort对距离排序 

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
typedef long long ll;
const int N = 2e5 + 1, inf = 0x3f3f3f3f;
struct Graph
{
	ll u, v, w;
	Graph() {}
	Graph(ll u, ll v, ll w) :u(u), v(v), w(w) {}
	bool operator <(const Graph& t)const
	{
		return w < t.w;
	}

}G[N];
ll d[810][810];
ll ans[N];
ll ver[N];
bool st[N];
ll id = 0;
ll cnt = 0;
ll n, m, k;
void build()
{
	int u, v, w;
	for (int i = 0; i < min(m, k); i++)
	{
		u = G[i].u, v = G[i].v, w = G[i].w;
		if (!st[u])  st[u] = true, ver[u] = ++id;
		if (!st[v])  st[v] = true, ver[v] = ++id;//不要加终止符
		d[ver[u]][ver[v]] = d[ver[v]][ver[u]] = w;
	}

}
void floyd()
{
	for (int k = 1; k <= id; k++)
	{
		for (int i = 1; i <= id; i++)
		{
			for (int j = 1; j <= id; j++)
			{
				d[i][j] = min(d[i][k] + d[k][j], d[i][j]);
			}
		}
	}
	for (int i = 1; i <= id; i++)
	{
		for (int j = 1; j < i; j++)//不包括自己
		{
			ans[cnt++] = d[i][j];
		}
	}
}
int main()
{

	scanf("%d%d%d", &n, &m, &k);
	for (int i = 0; i < m; i++)
	{
		int u, v, w;
		scanf("%d%d%d", &u, &v, &w);
		G[i] = { u,v,w };
	}
	sort(G, G + m);
	memset(d, inf, sizeof(d));
	build();
	floyd();
	sort(ans, ans + cnt);
	cout << ans[k - 1] << endl;

}

匿名函数写法：

sort(v.begin(),v,end(),[](auto&x,auto&y){return x>y;});

2.反向输出链表(利用栈的特性)

p2 = p1->next;
p3 = p2->next; //p2会产生空指针 因为p1->next是空 不能赋值给p2否则会报错



应该写成:
p1->next=p2;
p2->next=p3;

#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
using namespace std;
//反向输出链表 采用栈的特点
struct ListNode
{
	int val;
	struct ListNode* next;
	ListNode(int x) :val(x), next(NULL){}
};
class Solution
{
public:
	vector<int> out_inverse(ListNode* head)
	{
		stack<int>s;
		vector<int>ans;
		ListNode* pNode = head;
		while (pNode!=NULL)
		{
			s.push(pNode->val);
			pNode = pNode->next;
		}
		while (!s.empty())
		{
			ans.push_back(s.top());
			s.pop();
		}
		return ans;
	}
};
int main()
{
	Solution s;
	ListNode* p1 = new ListNode(1);
	ListNode* p2 = new ListNode(2);
	ListNode* p3 = new ListNode(3);
	p1->next = p2;
	p2->next = p3;
	vector<int>love;
	love = s.out_inverse(p1);
	for (int i = 0; i < love.size(); i++)
	{
		if (0!=i)
		{
			cout << " " << love[i];
		}
		else
		{
			cout << love[i];
		}
		
	}
}

3.在二叉搜索树中输出第k小的元素

思路分析:利用二叉树搜索树中序遍历是单调递增的情况来进行递归求解

#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
using namespace std;
//反向输出链表 采用栈的特点
class Node
{
public:
	int val;
	Node* left;
	Node* right;
	Node* root;
	Node* parent;
	Node(int x) :val(x) { left = NULL; right = NULL; parent = NULL; }
	Node() { left = NULL; right = NULL; root = NULL; parent = NULL; }//一开始初始化
	void insert(int key)
	{
		if (NULL == root)
		{
			root = new Node(key);
			return;
		}
		Node* pnode = root;
		Node* pparent = NULL;
		while (NULL != pnode)
		{
			if (key > pnode -> val)
			{
				pparent = pnode;
				pnode = pnode->right;
			}
			else if (key < pnode->val)
			{
				pparent = pnode;
				pnode = pnode->left;
			}
			else
			{
				break;
			}
		}
		//走到最后
		pnode = new Node(key);//走到最后生成新节点
		if (key > pparent->val)
		{
			pparent->right = pnode;
			pnode->parent = pparent;
		}
		else if (key < pparent->val)
		{
			pparent->left = pnode;
			pnode->parent = pparent;
		}
		else
		{
			return;
		}
	}
};
class Solution
{
public:
	
	int kthSmallest(Node*root, int k)
	{
		int res = 0;
		inOrder(root, k, res);
		return res;
	}
	
private:
	//对于递归（栈的形式)的理解 每次都把一个新的节点看成一个根节点去遍历 
	void inOrder(Node* root, int& k, int& res)//中序遍历就是层递增的顺序 因此求第k小可直接用中序来求
	{
		if (!root || !k) { return; }//递归要有终止条件 假如搜索到后面
		inOrder(root->left, k, res);
		if (--k == 0)
		{
			res = root->val;
		}
		inOrder(root->right, k, res);
	}
};
int main()
{
	Node *p=new Node();
	p->insert(5);
	p->insert(3);
	p->insert(6);
	p->insert(4);
	p->insert(2);
	p->insert(1);
	Solution s;
	cout << s.kthSmallest(p->root, 4) << endl;//应该传过去根节点
}

4.最大频率栈:每次都把若干个元素中出现频率最大的给进行弹出，若频率相同，则弹出离栈顶最近的

题目:895. 最大频率栈 - 力扣（LeetCode） (leetcode-cn.com)

思路分析:

1.最大频率用map进行存储

2.弹出栈顶最近的：则采用编号法，离栈顶近的编号大，这里采用自定义排序

自定义排序只能有大于或者小于或者等于 不能大于等于或小于等于

priority_queue内部 只能自定义<

AC代码:

#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
using namespace std;
//最高频率栈
//push 将整数x推入栈中 
//pop  移除并返回栈中出现最频繁的元素
//如果最频繁的元素不只一个，则移除并返回最接近栈顶的元素
struct Me
{
	int num, fre, order;//数字本身 频率 数字的顺序
	Me(int num, int fre, int order) :num(num), fre(fre), order(order) { ; }
	bool operator < (const Me& m)const//用于priority内部比较
	{
		if (fre == m.fre) { return order < m.order; }//频率相同比顺序
		else { return fre < m.fre; }//否则直接比频率
	}
	//排序的方式
};
priority_queue<Me>q;
map<int, int>mp;//记录每个数字以及其对应的次数
int t;
void Frestack()
{
	while (!q.empty()) { q.pop(); }
	mp.clear();
	t = 0;
}
void push(int x)
{
	mp[x] += 1;
	q.push({ x,mp[x],++t });
}
int pop()
{
	Me t = q.top();
	mp[t.num] -= 1;
	q.pop();
	return t.num;
}
int main()
{
	for (int i = 1; i <= 6; i++)
	{
		int x;
		cin >> x;
		push(x);
	}
	cout << pop() << endl;
	cout << pop() << endl;
	cout << pop() << endl;
	cout << pop() << endl;

}