mathematical method
mathematical method
曲线拟合
- 指数 \(lnY = lna + bX\)
- 对数 \(Y = blnX + a\)
- 幂函数 \(lgY=lga+blgX\)
多元线性回归模型
- 回归分析中有两个或者两个以上的自变量,就是多元回归
- 最小化残差平方和 SSE
图论: Floyd
#include <iostream>
using namespace std;
const int maxn = 200;
int n,s,t;
int a[maxn+1][maxn+1];
void init()
{
int m,u,v;
cin >> n >> m;
for(int i =1; i<=n; i++)
for(int j =1; j<=n; j++)
a[i][j] = -1;
for(int i = 1; i<=m; i++)
cin >> u >> v >> a[u][v];
cin >> s >> t;
}
void floyd()
{
int i,j,k;
for(k=1; k<=n; k++)
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
{
if(a[i][k]!=-1&&a[k][j]!=-1)
a[i][j] = min(a[i][j],a[i][k]+a[k][j]);
}
}
int main()
{
init();
floyd();
cout << a[s][t]+a[t][s]<<endl;
return 0;
}
图论: Prim 算法
- 解决最小生成树问题
- 采用的方法是加点法
- 在所有加过的点中找到距离其他点最短路径的点&&不能构成回路,加入集合,
//这里使用无向图
#include <iostream>
using namespace std;
const int MAXN = 2001;
const int INF = 99999999;
int n,e;
int w[MAXN][MAXN];
int mincount[MAXN]; //从初始顶点到该顶点的最小权值
void init()
{
int i,j;
int tx,ty;
for(i = 0; i<=MAXN; i++)
for(j =0; j<MAXN; j++)
w[i][j] = INF;
cin >> n >> e;
for(i = 1; i<=e; i++)
{
cin >> tx >> ty >> w[tx][ty];
w[ty][tx] = w[tx][ty];
}
}
void prim(int s) //从标号为s处开始生成树
{
int i,j,cnt = 0,min; // cnt 是生成树所有边的权值之和
int k;
for(i = 1; i<= n; i++)
mincount[i] = w[s][i]; // 初始化，设w[1][i]是初始点k到i的最小权值，如果没有就设为INF
mincount[s] = 0;
for(i = 1; i < n; i++) //一共有n-1次
{
min = INF;
for(j = 1; j <= n; j++)
{
if(mincount[j]!=0 && mincount[j]<min)
{
min = mincount[j];
k = j; //记录该点
}
mincount[k] = 0;//将该点加入到最小生成树中
cnt += min; //将这条边权值加入到最小生成树中
for(j = 1;j<=n;j++) //修正初始点到每个点的最小权值
{
if(w[k][j]<mincount[j])
mincount[j] = w[k][j];
}
}
}
cout << cnt << endl;
}
int main()
{
init();
prim(1);
return 0;
}
图论: Kruskal算法 - 加边法
- 主要用到的是并查集
#include <iostream>
using namespace std;
const int MAXN = 2000;
const int INF = 99999999;
int n,e;// n是点的数量，e是边的数量
int x[MAXN],y[MAXN],w[MAXN];
int parent[MAXN];
int Find(int x)
{
if(parent[x] == x)
return x;
else
return parent[x] = Find(parent[x]);
}
void Merge(int a,int b)
{
int pa = Find(a);
int pb = Find(b);
if(pb < pa)
swap(pb,pa);
if(pa!=pb)
parent[pa] = pb;
}
void kruskal()
{
int i,p,ans; //p是已经加入的边数,ans是加入边的边权之和
for(i = 1; i<=n ; i++) //initialize
{
parent[i] = i;
}
p = 1;
ans = 0;
for(i = 1; i <= e; i++)
{
if(Find(x[i])!=Find(y[i]))// 两点没有在同一个集合中,归并两个集合
{
ans += w[i];
Merge(x[i],y[i]);
p++;
if(p == n) //这里不是n-1，因为初始化的时候,p = 1
{
cout << ans << endl;
return;
}
}
}
return;
}
void sort(int i, int j)
{
if(i >=j)
return;
int m,n,k;
m = i;
n = j;
k = w[(i+j)>>1];
while(m <= n)
{
while(w[m]<k)
m++;
while(w[n]>k)
n--;
if(m <= n)
{
swap(x[m],x[n]);
swap(y[m],y[n]);
swap(w[m],w[n]);
m++;
n--;
}
}
sort(i,n);
sort(m,j);
}
int main()
{
int i,j;
cin >> n >> e;
for(i = 1; i <= e ; i++)
{
cin >> x[i] >> y[i] >> w[i];
}
sort(1,e);
kruskal();
return 0;
}
最大流 - Ford fulkerson算法
残余网络 & 增广路径
Ford-Fulkerson方法的正确性依赖于这个定理：当残存网络中不存在一条从s到t的增广路径，那么该图已经达到最大流。
伪代码
Ford-Fulkerson
for <u,v> ∈ E
<u,v>.f = 0
while find a route from s to t in e
m = min(<u,v>.f, <u,v> ∈ route)
for <u,v> ∈ route
if <u,v> ∈ f
<u,v>.f = <u,v>.f + m
else
<v,u>.f = <v,u>.f - m
实现过程中的重点自傲与如何寻找增广路径
- 可以使用广度搜索
- 可以用Bellmanford算法进行计算
- 残存网络就是在流网络的基础上改变的,容量仍然保持不变,只改变已经用过的容量.将其反向如果流量为0那就不用再表示在图上了
#include<stdio.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
#define MAXVEX 100
#define INF 65535
//用于表示边的结构体
struct edge
{
int to;//终点
int cap;//容量
int rev;//反向边
};
std::vector<edge>G[MAXVEX];//图的邻接表表示
bool used[MAXVEX];//DFS中用到的访问标记
//向图中增加一条从s到t容量为cap的边
void addEdge(int from, int to, int cap)
{
edge e;
e.cap = cap;e.to = to;e.rev = G[to].size();
G[from].push_back(e);
e.to = from; e.cap = 0; e.rev = G[from].size() - 1;
G[to].push_back(e);
}
//通过DFS寻找增广路
int dfs(int v, int t, int f)
{
if (v == t)return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i)
{
edge &e = G[v][i];
if (!used[e.to] && e.cap > 0)
{
int d = dfs(e.to, t, std::min(f, e.cap));
if (d > 0){
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
//求解从s到t的最大流
int max_flow(int s, int t)
{
int flow = 0;
for (;;)
{
memset(used, 0, sizeof(used));
int f = dfs(s, t, INF);
if (f == 0)return flow;
flow += f;
}
}
代码改变世界
