您的位置：首页 > 编程语言 > C语言/C++

BUAA_C++算法板子积累_动态规划、图算法、计算几何、FFT

2022-01-24 00:00 591 查看

Hello

#include <iostream>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <stack>

using namespace std;
typedef long long ll;

int main() {
cout << "Hello world!" << endl;
return 0;
}

标准库

<algorithm>

__gcd(a, b)				// 求两个数的最大公因数
__builtin_popcount(a)			// 求 int 的二进制里多少个 1

is_sorted(a, a + n)			// 是否升序
is_sorted_until(a, a + n)		// 到哪里是升序
sort(a, a + n)				// 不稳定排序(默认升序)
sort(a, a + n, greater<int>())	        // 降序排序
stable_sort(a, a + n)			// 稳定排序
nth_element(a, a + k, a + n)	        // 将第 k 大元素放到 a[k]
unique(begin, end)			// 对有序数组去重，返回末尾地址

max(a, b)				// 返回较大值
min(a, b)				// 返回较小值
max_element(a, a + n)			// 返回最大值位置
min_element(a, a + n)			// 返回最小值位置

lower_bound(a, a + n, key)		// 返回第一个不小于 key 的元素的位置
upper_bound(a, a + n, key)		// 返回第一个大于 key 的元素的位置
binary_search(a, a + n, key)	        // 二分查找是否存在

is_heap(a, a + n)			// 判断是否为大顶堆
is_heap_until(a, a + n)			// 到哪里是大顶堆
make_heap(a, a + n)			// 区间建堆
push_heap(a, a + n)			// 末尾元素入堆并调整，与 push_back() 配合
pop_heap(a, a + n)			// 堆顶移到末尾并调整，与 pop_back() 配合
sort_heap(a, a + n)			// 升序堆排序

is_permutation()			// 两个序列是否互为另一个的排序
next_permutation()			// 下一个排序
prev_permutation()			// 上一个排序

fill(a, a + n, val)			// 批量赋值
reverse(a, a + n)			// 数组翻转

<vector>

v.at(k)					// 访问 v[k]
v.front()				// 首元素
v.back()				// 末元素
v.begin()				// 首地址(迭代器)
v.end()					// 末地址(迭代器)
v.empty()				// 是否空
v.size()				// 大小
v.max_size()				// 最大空间
v.clear()				// 清除
v.insert(pos, item)			// 在 pos(迭代器) 位置插入 item
v.eraze(pos)				// 擦除 pos(迭代器) 位置的元素
v.push_back(item)			// 末尾插入
v.pop_back()				// 末尾删除

<queue>

/*----- queue -----*/
q.front()				// 访问队头
q.back()				// 访问队尾
q.empty()				// 是否空
q.size()				// 大小
q.push(item)				// item 入队
q.emplace(item)				// item 替换队尾
q.pop()					// 出队
/*----- priority_queue -----*/
priority_queue<int, vector<int>, greater<int>> pq
pq.top()				// 访问队首
pq.empty()				// 优先队列是否空
pq.size()				// 大小
pq.push(item)				// 插入 item
pq.pop()				// 出队

<stack>

s.top()					// 访问栈顶
s.empty()				// 栈是否空
s.size()				// 大小
s.push(item)				// item 入栈
s.emplace(item)				// item 替换栈顶
s.pop()					// 出栈

<set>

/*----- set -----*/
s.size()				// 大小
s.empty()				// 是否空
s.clear()				// 清除
s.insert(key)				// 插入
s.erase(pos/key)			// 删除
s.count(key)				// 是否存在
s.find(key)				// 查找，成功返回位置，失败返回 s.end()
/*----- multiset -----*/
ms.size()				// 大小
ms.empty()				// 是否空
ms.clear()				// 清除
ms.insert(key)				// 插入
ms.erase(pos/key)			// 删除
ms.count(key)				// 计数
ms.find(key)				// 查找，成功返回位置，失败返回 s.end()

<map>

/*----- map -----*/
/*----- mulmap -----*/

<unordered_set>

/*----- unordered_set -----*/
/*----- unordered_multiset -----*/

<unordered_map>

/*----- unordered_map -----*/
/*----- unordered_multimap -----*/

分治

逆序对计数

#include <iostream>

using namespace std;
typedef long long ll;

int temp[200005];

ll solve(int a[], int left, int right);

int main() {
int n;
int a[200005] = {};
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
cout << solve(a, 0, n - 1);
return 0;
}
ll solve(int a[], int left, int right) {
if (left == right)
return 0;
else {
int mid = (right - left) / 2 + left;
ll s1 = solve(a, left, mid);
ll s2 = solve(a, mid + 1, right);
ll s3 = 0;
int i = left, j = mid + 1, k = 0;
while (i <= mid && j <= right) {
if (a[i] <= a[j]) {
temp[left + k] = a[i];
k++;
i++;
} else {
temp[left + k] = a[j];
s3 += (mid - i + 1);
k++;
j++;
}
}
if (i <= mid)
while (i <= mid) {
temp[k + left] = a[i];
k++;
i++;
}
else
while (j <= right) {
temp[k + left] = a[j];
k++;
j++;
}
for (int l = left; l <= right; l++)
a[l] = temp[l];
return s1 + s2 + s3;
}
}

动态规划

01 背包

#include <iostream>
#include <algorithm>

#define ll long long
#define MAX_NUM 1005   //物品数量
#define MAX_CAP 100005 //最大容量
using namespace std;

ll dp[MAX_CAP];
int v[MAX_NUM];
int w[MAX_NUM];

ll backBag(ll Bag[], int *value, int *weight, int num, int cap) {
// dp数组，价值，重量，容量
for(int i = 0; i <= cap; i++)
Bag[i] = 0;
for (int i = 1; i <= num; i++)
for (int j = cap; j >= weight[i]; j--) //倒着dp
Bag[j] = max(Bag[j - weight[i]] + value[i], Bag[j]);
return Bag[cap];
}

int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++)
cin >> v[i] >> w[i];
cout << backBag(dp, v, w, n, k);
return 0;
}

完全背包

#include <iostream>
#include <algorithm>

#define ll long long
#define MAX_NUM 10005    //物品数量
#define MAX_CAP 10000005 //最大容量
using namespace std;

ll dp[MAX_CAP];
int v[MAX_NUM];
int w[MAX_NUM];

ll backBag(ll Bag[], int *value, int *weight, int num, int cap) {
// dp数组，价值，重量，容量
for(int i = 0; i <= cap; i++)
Bag[i] = 0;
for (int i = 1; i <= num; i++)
for (int j = weight[i]; j <= cap; j++) //正着dp
Bag[j] = max(Bag[j - weight[i]] + value[i], Bag[j]);
return Bag[cap];
}

int main() {
int n, k;
cin >> k >> n;
for (int i = 1; i <= n; i++)
cin >> w[i] >> v[i];
cout << backBag(dp, v, w, n, k);
return 0;
}

分组背包

#include <iostream>
#include <algorithm>

typedef long long ll;

const int MAX = 1005;

struct {
int cnt;
ll ID[MAX];
} group[MAX];   //用一个结构体来存储每一组的物品编号

ll dp[MAX];
ll val[MAX];
ll weight[MAX];

ll group_bag(int cap, int max_group);

using namespace std;

int main() {
//    freopen("a.in", "r", stdin);
//    freopen("a.out", "w", stdout);
int n, m;
cin >> m >> n;
int a, b, k, max_group = 0;
for (int i = 1; i <= n; i++) {
cin >> a >> b >> k;
weight[i] = a;
val[i] = b;
group[k].ID[group[k].cnt++] = i;
max_group = max(max_group, k);
}
cout << group_bag(m, max_group);
return 0;
}

ll group_bag(int cap, int max_group) {
for (int i = 0; i <= max_group; i++)            // 第一层组循环
for (ll j = cap; j >= 0; j--)               // 第二层容量倒着循环
for (int k = 0; k < group[i].cnt; k++)  // 第三层组内循环
if (j >= weight[group[i].ID[k]])
dp[j] = max(dp[j],
dp[j - weight[group[i].ID[k]]] + val[group[i].ID[k]]);
return dp[cap];
}

最大子列和

#include <iostream>
#include <algorithm>

#define MAX 1000005
#define ll long long
using namespace std;

int a[MAX];

ll maxSubArray(int *array, int n) {
ll Max = -0x3f3f3f3f3f3f3f3f;
ll sum = 0;
for (int i = n - 1; i >= 0; i--) {
if (sum <= 0)
sum = array[i];
else
sum += array[i];
Max = max(sum, Max);
}
return Max;
}

int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
cout << maxSubArray(a, n);
return 0;
}

LCS 最长公共子序列

#include <iostream>
#include <string>
#define MAX 1005
using namespace std;

struct Tab{
int x, y;
} trac[MAX][MAX];

int lcs[MAX][MAX];

void print_lcs(string str, int i, int j);

int main() {
int k;
cin >> k;
string sa, sb;
cin >> sa >> sb;
int la = (int)sa.length();
int lb = (int)sb.length();
for (int i = 1; i <= la; i++) {
for (int j = 1; j <= lb; j++) {
if (sa[i - 1] == sb[j - 1]) {
lcs[i][j] = lcs[i - 1][j - 1] + 1;
trac[i][j] = {i - 1, j - 1};
} else if (lcs[i - 1][j] >= lcs[i][j - 1]) {
lcs[i][j] = lcs[i - 1][j];
trac[i][j] = {i - 1, j};
} else {
lcs[i][j] = lcs[i][j - 1];
trac[i][j] = {i, j - 1};
}
}
}
if(k == 0)
cout << lcs[la][lb];
else
print_lcs(sa, la, lb);
return 0;
}

void print_lcs(string str, int i, int j){
if(i == 0 || j == 0)
return ;
if(trac[i][j].x == i - 1 && trac[i][j].y == j - 1){
print_lcs(str, i - 1, j - 1);
cout << str[i - 1];
}else if(trac[i][j].x == i - 1 && trac[i][j].y == j)
print_lcs(str, i - 1, j);
else
print_lcs(str, i, j - 1);
}

最小编辑距离

#include <iostream>
#include <string>
#define MAX 2005
using namespace std;

int min3(int a, int b, int c) {
int m = a;
if (b < m)
m = b;
if (c < m)
return c;
return m;
}
int minDistance(string word1, string word2) {
int dp[2][MAX] = {};
int l1 = word1.length();
int l2 = word2.length();
for (int j = 0; j <= l2; j++)
dp[0][j] = j;
for (int i = 1; i <= l1; i++) {
dp[1][0] = i;
for (int j = 1; j <= l2; j++)
if (word1[i - 1] == word2[j - 1])
dp[1][j] = dp[0][j - 1];
else
dp[1][j] = min3(dp[0][j - 1], dp[0][j], dp[1][j - 1]) + 1;
for (int j = 0; j <= l2; j++)
dp[0][j] = dp[1][j];
}
return dp[0][l2];
}
int main() {
string a;
string b;
cin >> a >> b;
cout << minDistance(a, b);
return 0;
}

最长单调子序列

// 严格单调递增子列的长度
int lsrsa(const vector<int> &a) {
vector<int> sa;
for (auto x: a) {
if (sa.empty() || x > sa.back())
sa.push_back(x);
else
*lower_bound(sa.begin(), sa.end(), x) = x;
}
return (int) sa.size();
}
// 单调不减子列的长度
int lrsa(const vector<int> &a) {
vector<int> sa;
for (auto x: a) {
if (sa.empty() || x >= sa.back())
sa.push_back(x);
else
*upper_bound(sa.begin(), sa.end(), x) = x;
}
return (int) sa.size();
}

图算法

链式前向星

struct Edge{
int to, w, next;			//终点，权值，前驱
} e[E_MAX];

int cnt_E = 0;
int head[V_MAX];			//需要先初始化为-1

void intList(int n){
memset(head, -1, sizeof(head));
}

void addEdge(int x, int y, int w){
e[cnt_E].to = y;          	        //保存终点
e[cnt_E].next = head[x]; 	        //添加链接
head[x] = cnt++;			//更新表头
}

Dijkstra 最短路（标准版）

#include <iostream>
#include <vector>
#include <cstring>

#define V_MAX 100005
#define INF 0x3f3f3f3f3f3f3f3f

using namespace std;
typedef long long ll;

struct Edge {
int to;
ll weight;
};

vector<Edge> e[V_MAX];
ll dis[V_MAX];
bool vis[V_MAX];
int n, m;

void addEdge(int u, int v, ll w);
void dijkstra(int s);

int main() {
int s;
cin >> n >> m >> s;
int x, y;
ll w;
for (int i = 0; i < m; ++i) {
cin >> x >> y >> w;
addEdge(x, y, w);
}
dijkstra(s);
// 最短路保存在 dis 中
for (int i = 1; i <= n; i++) {
if (dis[i] == INF)
cout << -1 << " ";
else
cout << dis[i] << " ";
}
return 0;
}

void addEdge(int u, int v, ll w) {
e[u].push_back({v, w});
}

void dijkstra(int s) {
memset(dis, 0x3f, sizeof(dis));
dis[s] = 0;
for (int i = 1; i <= n; i++) {
int u = 0;
ll mind = INF;
for (int j = 1; j <= n; j++)
if (!vis[j] && dis[j] < mind) {
u = j;
mind = dis[j];
}
vis[u] = true;
for (auto ed: e[u]) {
int v = ed.to;
ll w = ed.weight;
if (dis[v] > dis[u] + w)
dis[v] = dis[u] + w;
}
}
}

Dijkstra 最短路（堆优化）

#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>

#define  V_MAX 100005
#define INF 0x3f3f3f3f3f3f3f3f

using namespace std;

typedef long long ll;

struct Edge {
int to;
ll w;
};

struct Node {
ll dis;
int u;
bool operator>(const Node &b) const {return dis > b.dis; }
};

vector<Edge> e[V_MAX];

void addEdge(int u, int v, ll w) {
e[u].push_back({v, w});
}

vector<ll> dijkstra(int s) {
priority_queue<Node, vector<Node>, greater<Node>> q;
vector<ll> dis(V_MAX);
fill(dis.begin(),  dis.end(), INF);
vector<bool> vis(V_MAX);
dis[s] = 0;
q.push({0, s});
while (!q.empty()){
int u = q.top().u;
q.pop();
if(vis[u])continue;
vis[u] = true;
for (auto ed : e[u]){
int v = ed.to;
ll w = ed.w;
if(dis[v] > dis[u] + w){
dis[v] = dis[u] + w;
q.push({dis[v], v});
}
}
}
return dis;
}

int main() {
int n, m;
int s;
cin >> n >> m >> s;
int x, y, w;
for (int i = 0; i < m; i++) {
cin >> x >> y >> w;
addEdge(x, y, w);
}
vector<ll> dis = dijkstra(s);
for (int i = 1; i <= n; i++) {
cout << dis[i] << " ";
}
return 0;
}

Floyd 最短路

#include <algorithm>
#include <cstring>
#include <iostream>

#define V_MAX 510				// 结点数
#define INF 0x3f3f3f3f3f3f3f3f

using namespace std;
typedef long long ll;

ll f[V_MAX][V_MAX];				// 邻接矩阵存图

int main() {
int n, m, p;
ll x, y, w;
cin >> n >> m >> p;
for (x = 1; x <= n; x++)
for (y = 1; y <= n; y++)
f[x][y] = INF;
for (int i = 1; i <= n; i++)
f[i][i] = 0;

/*-----初始化部分-----*/

for (int i = 0; i < m; i++) {
cin >> x >> y >> w;
if (w < f[x][y])			// 考虑重边的情况
f[x][y] = w;
}

/*-----读入-----*/

for (int k = 1; k <= n; k++)
for (x = 1; x <= n; x++)
for (y = 1; y <= n; y++)
f[x][y] = min(f[x][y], f[x][k] + f[k][y]);

/*----- Floyd -----*/

for (int i = 0; i < p; i++) {
cin >> x >> y;
if (f[x][y] != INF)
cout << f[x][y] << endl;
else
cout << "-1" << endl;
}

/*-----输出-----*/
return 0;
}

Kruskal 最小生成树

#include <algorithm>
#include <iostream>

#define V_MAX 300005
#define E_MAX 500005

using namespace std;
typedef long long ll;

struct Edge {
int x, y, w;
bool operator<(const Edge &b) const { return w < b.w; }
} e[E_MAX];

int v[V_MAX];

int Find(int x);
bool isUnion(int x, int y);
void Union(int x, int y);	//合并
void makeSet(int n);		//初始化并查集

int main() {
int n, m;
cin >> n >> m;
makeSet(n);
for (int i = 0; i < m; i++)
cin >> e[i].x >> e[i].y >> e[i].w;
sort(e, e + m);
int cnt = 0;
ll sum = 0;
for(int i = 0; cnt < n - 1; i++){
if(isUnion(e[i].x, e[i].y))
continue;
cnt++;
sum += e[i].w;
Union(e[i].x, e[i].y);
}
cout << sum;
return 0;
}

void makeSet(int n) {
for (int i = 1; i <= n; i++)
v[i] = i;
}

int Find(int x) {
if (v[x] == x)
return x;
return v[x] = Find(v[x]);
}

bool isUnion(int x, int y) { return Find(x) == Find(y); }
void Union(int x, int y) { v[Find(y)] = Find(x); }

Kahn 拓扑排序

#include <cstring>
#include <iostream>
#include <queue>
#include <vector>

#define E_MAX 400005
#define V_MAX 100005

using namespace std;

struct Edge {			//链式前向星，存边的起点、终点、和前驱
int x, y, next;
} e[E_MAX];

int head[V_MAX]; 		//下标是起点的表头，存第一个边的编号，初始化为 -1
int id[V_MAX];			//每个点的入度
int cnt;			//存储的边数

void addEdge(int x, int y);
bool Kahn(int n);

int main() {
int n, m, x, y;
cin >> n >> m;

fill(head + 1, head + 1 + n, -1);

/*----- 初始化 -----*/

for (int i = 0; i < m; i++) {
cin >> x >> y;
addEdge(x, y);
}

/*----- 读入边 -----*/

Kahn(n);
return 0;
}
void addEdge(int x, int y) {
e[cnt].x = x;          		//起点
e[cnt].y = y;          		//终点
e[cnt].next = head[x]; 		//添加
id[y]++;
head[x] = cnt++;			//更新表头
}
bool Kahn(int n) {
priority_queue<int> q;		//优先队列
for (int i = 1; i <= n; i++) {
if (id[i] == 0)
q.push(i);			//把入度为0的点入队
}
vector<int> ans;			//数组保存结果
while (!q.empty()) {
int x = q.top();		//出队
q.pop();
ans.push_back(x);
int edge = head[x];
while (edge != -1) {
id[e[edge].y]--;		//删除边
if (id[e[edge].y] == 0)
q.push(e[edge].y);
edge = e[edge].next;
}
}
if (ans.size() == n) {
for (int an : ans)
cout << an << " ";
return true;
}

/*----- 无环则输出并返回真 -----*/

return false;
}

Dinic 最大流

#include <algorithm>
#include <cstring>
#include <iostream>
#include <queue>
using namespace std;
typedef long long ll;
const int V_MAX = 205;
const int E_MAX = 5005;
const ll LL_INF = 0x3f3f3f3f3f3f3f3f;

ll max_stream = 0;
int cnt_E = 0;
int n, m, s, t;

struct Edge {
int to;
int nxt;
ll val;
} e[E_MAX * 2];

int head[V_MAX];
int depth[V_MAX];

void addEdge(int x, int y, int w);
void read();
bool bfs();
ll Dinic();

int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> s >> t;

fill(head + 1, head + 1 + n, -1);

/*----- 读入并初始化 -----*/

read();
cout << Dinic();
return 0;
}
void addEdge(int x, int y, int w) {
e[cnt_E].to = y;
e[cnt_E].val = w;
e[cnt_E].nxt = head[x];
head[x] = cnt_E++;
}
void read() {
int u, v, w;
for (int i = 0; i < m; i++) {
cin >> u >> v >> w;
addEdge(u, v, w);
addEdge(v, u, 0);
}
}
bool bfs() {
memset(depth, 0, sizeof(depth));
depth[s] = 1;
queue<int> q;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i > -1; i = e[i].nxt) {
int v = e[i].to;
if (e[i].val && !depth[v]) {
depth[v] = depth[u] + 1;
q.push(v);
}
}
}
if (depth[t] != 0)
return true;
return false;
}

ll dfs(int pos, ll in) {
if (pos == t)
return in;
ll out = 0;
for (int u = head[pos]; u > -1 && in; u = e[u].nxt) {
int v = e[u].to;
if (e[u].val && depth[v] == depth[pos] + 1) {
ll res = dfs(v, min(e[u].val, in));
e[u].val -= res;
e[u ^ 1].val += res;
in -= res;
out += res;
}
}
if (out == 0)
depth[pos] = 0;
return out;
}
ll Dinic() {
while (bfs())
max_stream += dfs(s, LL_INF);
return max_stream;
}

二分图匹配

#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>

using namespace std;

struct pos {
int x, y;
};

vector<pos> left;
vector<pos> right;

struct augment_path {
// 结点编号从 0 开始
vector<vector<int>> g;
vector<int> pa;
vector<int> pb;
vector<int> vis;
int n, m;
int dfn;
int res;

augment_path(int _n, int _m) : n(_n), m(_m) {
pa = vector<int>(n, -1);
pb = vector<int>(m, -1);
vis = vector<int>(n);
g.resize(n);
res = dfn = 0;
}

void add(int from, int to) {
g[from].push_back(to);
}

bool dfs(int v) {
vis[v] = dfn;
for (int u: g[v])
if (pb[u] == -1) {
pb[u] = v;
pa[v] = u;
return true;
}
for (int u: g[v])
if (vis[pb[u]] != dfn && dfs(pb[u])) {
pa[v] = u;
pb[u] = v;
return true;
}
return false;
}

int solve() {
while (true) {
dfn++;
int cnt = 0;
for (int i = 0; i < n; i++)
if (pa[i] == -1 && dfs(i))
cnt++;
if (cnt == 0)
break;
res += cnt;
}
return res;
}
};

int main() {
int n, m, e;
cin >> n >> m >> e;
augment_path solver(n, m);
int u, v;
for(int i = 0; i < e; i++){
cin >> u >> v;
solver.add(u - 1, v - 1);
}
cout << solver.solve() << endl;
return 0;
}

计算几何

线段相交计数

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

struct Point {
int x, y;

Point operator+(const Point &b) const {
return {x + b.x, y + b.y};
}

Point operator-(const Point &b) const {
return {x - b.x, y - b.y};
}

Point operator*(const int &b) const {
return {x * b, y * b};
}

int operator^(const Point &b) const {
return x * b.y - y * b.x;
}
};

struct Line {
Point p;
Point q;
};

vector<Line> lines;

bool intersect(Line l1, Line l2);

bool onSegment(Point point, Line line);

int main() {
int n, cnt = 0;
cin >> n;
int x1, y1, x2, y2;
for (int i = 0; i < n; i++) {
cin >> x1 >> y1 >> x2 >> y2;
lines.push_back({{x1, y1},
{x2, y2}});
}
for (int i = 0; i < n; i++)
for (int j = 0; j < i; j++)
if (intersect(lines[i], lines[j]))
cnt++;
cout << cnt;
return 0;
}

bool intersect(Line l1, Line l2) {
int d1 = (l1.q - l1.p) ^ (l2.p - l1.p);
int d2 = (l1.q - l1.p) ^ (l2.q - l1.p);
int d3 = (l2.q - l2.p) ^ (l1.p - l2.p);
int d4 = (l2.q - l2.p) ^ (l1.q - l2.p);
if (d1 * d2 < 0 && d3 * d4 < 0)
return true;
if (d1 == 0 && onSegment(l2.p, l1))
return true;
if (d2 == 0 && onSegment(l2.q, l1))
return true;
if (d3 == 0 && onSegment(l1.p, l2))
return true;
if (d4 == 0 && onSegment(l1.q, l2))
return true;
return false;
}

bool onSegment(Point point, Line line) {
if (point.x >= min(line.p.x, line.q.x) &&
point.x <= max(line.p.x, line.q.x) &&
point.y >= min(line.p.y, line.q.y) &&
point.y <= max(line.p.y, line.q.y))
return true;
return false;
}

Graham 凸包 + 旋转卡壳

#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstdio>

using namespace std;

const int MAX = 200005;
const double eps = 1e-7;

struct Point {
double x, y;

Point operator+(const Point &b) const {
return {x + b.x, y + b.y};
}

Point operator-(const Point &b) const {
return {x - b.x, y - b.y};
}

double operator^(const Point &b) const {
return x * b.y - y * b.x;
}

bool operator<(const Point &b) const {
if (x != b.x)
return x < b.x;
return y < b.y;
}
};

Point p[MAX];
Point s[MAX];
int top;

void selMin(int n);
int cmp(Point a, Point b);
bool equal(double a, double b);
double dis(Point a, Point b);
void graham(int n);
double s_sqr(Point a, Point b, Point c);
double diameter();

int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> p[i].x >> p[i].y;
selMin(n);
sort(p + 1, p + n, cmp);
graham(n);
printf("%.6f", sqrt(diameter())) ;
return 0;
}

void selMin(int n) {
Point Min = p[0];
int IDMin = 0;
for (int i = 0; i < n; i++)
if (p[i] < Min) {
Min = p[i];
IDMin = i;
}
swap(p[0], p[IDMin]);
}

int cmp(Point a, Point b) {
double x = (a - p[0]) ^ (b - p[0]);
if (x > 0)
return 1;
if (equal(x, 0) && (dis(a, p[0]) < dis(b, p[0])))
return 1;
return 0;
}

double dis(Point a, Point b) {
double x = a.x - b.x;
double y = a.y - b.y;
return x * x + y * y;
}

void graham(int n) {
top = 1;
s[0] = p[0];
s[1] = p[1];
for (int i = 2; i < n; i++) {
while (top > 1 && ((p[i] - s[top]) ^ (s[top - 1] - s[top])) <= 0)
top--;
s[++top] = p[i];
}
}

double s_sqr(Point a, Point b, Point c) {
return fabs((a - b) ^ (c - b));
}

double diameter() {
double diam = 0;
int j = 2;
s[++top] = s[0];
if (top < 3)
return dis(s[0], s[1]);
for (int i = 0; i < top - 1; i++) {
while (s_sqr(s[i], s[i + 1], s[j]) <
s_sqr(s[i], s[i + 1], s[(j + 1) % top]))
j = (j + 1) % top;
diam = max(diam, max(dis(s[i], s[j]), dis(s[i + 1], s[j])));
}
return diam;
}
bool equal(double a, double b){
return fabs(a - b) < eps;
}

其他算法

多项式乘法-FFT

#include <iostream>
#include <vector>
#include <cmath>

const double Pi = acos(-1);
const int MAX = 4000005;
using namespace std;
typedef long long ll;

struct Complex {
double x, y;

Complex operator+(const Complex &b) const {
return {x + b.x, y + b.y};
}

Complex operator-(const Complex &b) const {
return {x - b.x, y - b.y};
}

Complex operator*(const Complex &b) const {
return {x * b.x - y * b.y, x * b.y + y * b.x};
}
} f[MAX], p[MAX], sav[MAX];
void dft(Complex *f, int len);

void idft(Complex *f, int len);

int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i <= n; i++)
cin >> f[i].x;
for (int i = 0; i <= m; i++)
cin >> p[i].x;
for (m += n, n = 1; n <= m; n <<= 1);
dft(f, n);
dft(p, n);
for (int i = 0; i < n; i++)
f[i] = f[i] * p[i];
idft(f, n);
for (int i = 0; i <= m; i++)
cout << (int) (f[i].x / n + 0.49) << " ";
return 0;
}

void dft(Complex *f, int len) {
if (len == 1)
return;
Complex *fl = f, *fr = f + len / 2;
for (int k = 0; k < len; k++)
sav[k] = f[k];
for (int k = 0; k < len / 2; k++) {
fl[k] = sav[k << 1];
fr[k] = sav[k << 1 | 1];
}
dft(fl, len / 2);
dft(fr, len / 2);
Complex tG = {cos(2 * Pi / len), sin(2 * Pi / len)};
Complex buf = {1, 0};
for (int k = 0; k < len / 2; k++) {
sav[k] = fl[k] + buf * fr[k];
sav[k + len / 2] = fl[k] - buf * fr[k];
buf = buf * tG;
}
for (int k = 0; k < len; k++)
f[k] = sav[k];
}

void idft(Complex *f, int len) {
if (len == 1)
return;
Complex *fl = f, *fr = f + len / 2;
for (int k = 0; k < len; k++)
sav[k] = f[k];
for (int k = 0; k < len / 2; k++) {
fl[k] = sav[k << 1];
fr[k] = sav[k << 1 | 1];
}
idft(fl, len / 2);
idft(fr, len / 2);
Complex tG = {cos(2 * Pi / len), -sin(2 * Pi / len)};
Complex buf = {1, 0};
for (int k = 0; k < len / 2; k++) {
sav[k] = fl[k] + buf * fr[k];
sav[k + len / 2] = fl[k] - buf * fr[k];
buf = buf * tG;
}
for (int k = 0; k < len; k++)
f[k] = sav[k];
}

高精度乘法-FFT

#include <iostream>
#include <cmath>
#include <cstring>

const double Pi = acos(-1);
const int MAX = 4000005;
using namespace std;
typedef long long ll;

struct Complex {
double x, y;

Complex operator+(const Complex &b) const {
return {x + b.x, y + b.y};
}

Complex operator-(const Complex &b) const {
return {x - b.x, y - b.y};
}

Complex operator*(const Complex &b) const {
return {x * b.x - y * b.y, x * b.y + y * b.x};
}
} f[MAX], p[MAX], sav[MAX];

ll ans[MAX];
void dft(Complex *f, int len);

void idft(Complex *f, int len);

int main() {
char a[MAX], b[MAX];
scanf("%s%s", a, b);
int n = strlen(a);
int m = strlen(b);
for(int i = 0; i < n; i++)
f[i].x = a[n - i - 1] - '0';
for(int i = 0; i < m; i++)
p[i].x = b[m - i - 1] - '0';
for (m += n, n = 1; n <= m; n <<= 1);
dft(f, n);
dft(p, n);
for (int i = 0; i < n; i++)
f[i] = f[i] * p[i];
idft(f, n);
for (int i = 0; i <= m; i++)
ans[i] = (ll) (f[i].x / n + 0.49);
for(int i = 0; i < MAX; i++){
ans[i + 1] += (ans[i] / 10);
ans[i] %= 10;
}
int t = MAX - 1;
while (ans[t] == 0)
t--;
while (t >= 0)
cout << ans[t--];
cout << endl;
return 0;
}

void dft(Complex *f, int len) {
if (len == 1)
return;
Complex *fl = f, *fr = f + len / 2;
for (int k = 0; k < len; k++)
sav[k] = f[k];
for (int k = 0; k < len / 2; k++) {
fl[k] = sav[k << 1];
fr[k] = sav[k << 1 | 1];
}
dft(fl, len / 2);
dft(fr, len / 2);
Complex tG = {cos(2 * Pi / len), sin(2 * Pi / len)};
Complex buf = {1, 0};
for (int k = 0; k < len / 2; k++) {
sav[k] = fl[k] + buf * fr[k];
sav[k + len / 2] = fl[k] - buf * fr[k];
buf = buf * tG;
}
for (int k = 0; k < len; k++)
f[k] = sav[k];
}

void idft(Complex *f, int len) {
if (len == 1)
return;
Complex *fl = f, *fr = f + len / 2;
for (int k = 0; k < len; k++)
sav[k] = f[k];
for (int k = 0; k < len / 2; k++) {
fl[k] = sav[k << 1];
fr[k] = sav[k << 1 | 1];
}
idft(fl, len / 2);
idft(fr, len / 2);
Complex tG = {cos(2 * Pi / len), -sin(2 * Pi / len)};
Complex buf = {1, 0};
for (int k = 0; k < len / 2; k++) {
sav[k] = fl[k] + buf * fr[k];
sav[k + len / 2] = fl[k] - buf * fr[k];
buf = buf * tG;
}
for (int k = 0; k < len; k++)
f[k] = sav[k];
}

KMP 字符串匹配

#include <iostream>
#include <vector>
#include <string>

using namespace std;

vector<int> prefix(string str);

int main(){
string text;
string key;
cin >> text;
cin >> key;
int kl = key.length();
vector<int> kmp = prefix(key);
int k = 0;
for(int i = 0; i < text.length(); i++){
while (k && key[k] != text[i])
k = kmp[k - 1];
if(text[i] == key[k])
k++;
if(k == kl)
cout << i - k + 2 << endl;
}
for(auto x: kmp)
cout << x << " ";
return 0;
}
vector<int> prefix(string str){
int l = (int) str.length();
vector<int> pre(l);
for(int i = 1; i < l; i++){
int j = pre[i - 1];
while (j && str[j] != str[i])
j = pre[j - 1];
if(str[j] == str[i])
j++;
pre[i] = j;
}
return pre;
}

其它

快速幂取余

ll fast_pow_mod(ll a, ll b, ll m){
a %= m;
ll res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}

快速打质数表

vector<int> generate_prime_list(int n) {
if (n <= 2)
return vector<int>{2};
if (n <= 3)
return vector<int>{2, 3};
if (n <= 5)
return vector<int>{2, 3, 5};
vector<int> prime_list = {2, 3, 5};
int i = 1;
int x;
while (true) {
x = 6 * i + 1;
if (x > n)
break;
if (is_prime(x, prime_list))
prime_list.push_back(x);
x = 6 * i + 5;
if (x > n)
break;
if (is_prime(x, prime_list))
prime_list.push_back(x);
i++;
}
return prime_list;
}

bool is_prime(int x, const vector<int> &prime_list) {
for(auto u: prime_list){
if(x % u == 0)
return false;
if(u * u > x)
return true;
}
return false;
}

鸣谢

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航