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;
}