前方高能,小心吐血!!!
求赞
求赞
求赞
求赞
求赞!!!!!!!!!
算法一:直接算咯
#include <iostream>
using namespace std;
int main()
{
int a,b;
cin >>a >> b;
cout<< a + b << endl;
}
算法二:DFS一号
#include <bits/stdc++.h>
using namespace std;
int n = 2, a[5], s;
int dfs(int x, int sum) {
if (x > n) return sum;
int i = dfs(x + 1, sum);
int j = dfs(x + 1, sum + a[x]);
if (i == s) return i;
if (j == s) return j;
return -1;
}
int main() {
for (int i = 1;i <= n; i++) scanf("%d", &a[i]), s += a[i];
cout << dfs(1, 0) << endl;
return 0;
}
算法三:DFS二号:
#include <bits/stdc++.h>
using namespace std;
int a, b;
int dfs(int x) {
if (x <= 5) return x;
return dfs(x / 2) + dfs(x - x / 2);
}
int main() {
scanf("%d%d", &a, &b);
printf("%d\n", dfs(a) + dfs(b));
return 0;
}
算法四:BFS:
#include <bits/stdc++.h>
using namespace std;
int n = 2, a[5], s;
queue<int> q;
void bfs() {
q.push(0);
int c = 0;
while (q.size()) {
c++;
int f = q.front(); q.pop();
if (f == s) {printf("%d\n", f); exit(0);}
q.push(f + a[c]);
q.push(f);
}
}
int main() {
for (int i = 1;i <= n; i++) scanf("%d", &a[i]), s += a[i];
bfs();
return 0;
}
算法五:Dijstra最短路
#include <bits/stdc++.h>
using namespace std;
int w[5][5], d[5], v[5];
int n = 3;
void dijkstra() {
memset(d, 0x3f, sizeof d);
memset(v, 0, sizeof v);
d[1] = 0;
for (int i = 1;i < n; i++) {
int x = 0;
for (int j = 1;j <= n; j++)
if (!v[j] && (x == 0 || d[j] < d[x])) x = j;
v[x] = 1;
for (int y = 1;y <= n; y++)
d[y] = min(d[y], d[x] + w[x][y]);
}
}
int main() {
int a, b; scanf("%d%d", &a, &b);
memset(w, 0x3f, sizeof w);
w[1][2] = a; w[2][3] = b;
dijkstra();
printf("%d\n", d[3]);
return 0;
}
算法六:spfa
int a, b, n = 3;
int w[5][5], d[5], v[5];
queue<int> q;
void spfa() {
memset(d, 0x3f, sizeof d);
memset(v, 0, sizeof v);
d[1] = 0, v[1] = 1;
q.push(1);
while (q.size()) {
int x = q.front(); q.pop();
v[x] = 0;
for (int i = 1;i <= n; i++) {
// if (w[x][i] == 0x3f) continue;
if (d[i] > d[x] + w[x][i]) {
d[i] = d[x] + w[x][i];
if (!v[i]) q.push(i), v[i] = 1;
}
}
}
}
int main() {
scanf("%d%d", &a, &b);
memset(w, 0x3f, sizeof w);
w[1][2] = a; w[2][3] = b;
spfa();
printf("%d\n", d[3]);
return 0;
}
算法七:Floyd
#include <bits/stdc++.h>
using namespace std;
int d[5][5], n = 3;
int main() {
int a, b; scanf("%d%d", &a, &b);
memset(d, 0x3f, sizeof d);
d[1][2] = a; d[2][3] = b;
for (int k = 1;k <= n; k++)
for (int i = 1;i <= n; i++)
for (int j = 1;j <= n; j++)
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
printf("%d\n", d[1][3]);
return 0;
}
算法八:枚举一号:
#include <bits/stdc++.h>
using namespace std;
int a, b;
int main() {
scanf("%d%d", &a, &b);
for (int i = 0;i <= 2000000; i++) if (a + b == i) {printf("%d\n", i); break;}
return 0;
}
算法九:枚举二号:
#include <bits/stdc++.h>
using namespace std;
int a, b;
int main() {
scanf("%d%d", &a, &b);
for (int i = 0;i <= 2000000000; i++) if (a + b == i) {printf("%d\n", i); break;}
return 0;
}
算法十:高精度:
#include<bits/stdc++.h>
using namespace std;
string a0, b0;
int a[1005], b[1005];
int main(){
cin >> a0 >> b0;
int l1 = a0.size(), l2 = b0.size();
for (int i = 0;i < l1; i++) a[l1 - i] = a0[i] - 48;
for (int i = 0;i < l2; i++) b[l2 - i] = b0[i] - 48;
l1 = max(l1, l2);
for (int i = 1;i <= l1; i++) {
a[i] += b[i];
if (a[i] > 9) a[i + 1] += 1, a[i] %= 10;
}
if (a[max(l1, l2) + 1] > 0) l1++;
for (int i = l1;i >= 1; i--) printf("%d", a[i]);
return 0;
}
算法十一:压位高精度
#include<bits/stdc++.h>
#define p 8
#define carry 100000000
using namespace std;
const int Maxn=50001;
char s1[Maxn],s2[Maxn];
int a[Maxn],b[Maxn],ans[Maxn];
int change(char s[],int n[])
{
char temp[Maxn];
int len=strlen(s+1),cur=0;
while(len/p){
strncpy(temp,s+len-p+1,p);
n[++cur]=atoi(temp);
len-=p;
}
if(len){
memset(temp,0,sizeof(temp));
strncpy(temp,s+1,len);
n[++cur]=atoi(temp);
}
return cur;
}
int add(int a[],int b[],int c[],int l1,int l2)
{
int x=0,l3=max(l1,l2);
for(int i=1;i<=l3;i++){
c[i]=a[i]+b[i]+x;
x=c[i]/carry;
c[i]%=carry;
}
while(x>0){c[++l3]=x%10;x/=10;}
return l3;
}
void print(int a[],int len)
{
printf("%d",a[len]);
for(int i=len-1;i>=1;i--)printf("%0*d",p,a[i]);
printf("\n");
}
int main()
{
scanf("%s%s",s1+1,s2+1);
int la=change(s1,a);
int lb=change(s2,b);
int len=add(a,b,ans,la,lb);
print(ans,len);
}
算法十二 网络流1
#include<bits/stdc++.h>
using namespace std;
#define set(x) Set(x)
#define REP(i,j,k) for (int i=(j),_end_=(k);i<=_end_;++i)
#define DREP(i,j,k) for (int i=(j),_start_=(k);i>=_start_;--i)
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define mp make_pair
#define x first
#define y second
#define pb push_back
#define SZ(x) (int((x).size()-1))
#define ALL(x) ((x).begin()+1),(x).end()
template<typename T> inline bool chkmin(T &a,const T &b){ return a > b ? a = b, 1 : 0; }
template<typename T> inline bool chkmax(T &a,const T &b){ return a < b ? a = b, 1 : 0; }
typedef long long LL;
typedef pair<int,int> node;
const int dmax=1010,oo=0x3f3f3f3f;
int n,m;
int a[dmax][dmax] , ans;
int d[dmax],e[dmax];
priority_queue <node> q;
inline bool operator >(node a,node b){ return a.y>b.y; }
bool p[dmax];
void Set(int x){ p[x]=1; }
void unset(int x){ p[x]=0; }
bool check(int x){ return x!=1 && x!=n && !p[x] && e[x]>0; }
void preflow(){
e[1]=oo;
d[1]=n-1;
q.push(mp(1,n-1));
set(1);
while (!q.empty()){
bool flag=1;
int k=q.top().x;
q.pop(),unset(k);
DREP(i,n,1)
if ((d[k]==d[i]+1 || k==1) && a[k][i]>0){
flag=0;
int t=min(a[k][i],e[k]);
e[k]-=t;
a[k][i]-=t;
e[i]+=t;
a[i][k]+=t;
if (check(i)){
q.push(mp(i,d[i]));
set(i);
}
if (e[k]==0) break;
}
if (flag){
d[k]=oo;
REP(i,1,n)
if (a[k][i]>0)chkmin(d[k],d[i]+1);
}
if (check(k)){
q.push(mp(k,d[k]));
set(k);
}
}
ans=e[n];
}
int main(){
n = 2, m = 2;
int x, y;
scanf("%d%d", &x, &y);
a[1][2] += x + y;
preflow();
printf("%d\n",ans);
return 0;
}
算法十三 网络流2
#include <string>
#include <iostream>
using namespace std;
std::string Caculate(std::string &s1, std::string &s2)
{
const char *a = s1.c_str();
const char *b = s2.c_str();
int i1 = s1.length() - 1;
int i2 = s2.length() - 1;
std::string s;
int carry = 0;
while (i1 >= 0 || i2 >= 0)
{
char ch = carry;
if (i1 >= 0)
{
if (a[i1] < '0' || a[i1] > '9') return "第一个数输入错误!";
ch += a[i1] - '0';
}
if (i2 >= 0)
{
if (b[i2] < '0' || b[i2] > '9') return "第二个数输入错误!";
ch += b[i2] - '0';
}
if (ch >= 10)
{
carry = 1;
ch -= 10;
}
else carry = 0;
s.push_back(ch + '0');
i1--;
i2--;
}
if (carry) s.push_back('1');
reverse(s.begin(), s.end());
return s;
}
int main()
{
std::string s1, s2;
cout << "输入第一个数:";
cin >> s1;
cout << "输入第二个数:";
cin >> s2;
std::string result = Caculate(s1, s2);
cout << endl << "结果为:" << result << endl;
return 0;
}
算法十四 二分
#include<iostream>
using namespace std;
long long a,b,c;
long long dg(long long a)
{
if(a<=5)return a;
return (dg(a/2)+dg(a-a/2));
}
int main()
{
cin>>a>>b;
cout<<dg(a)+dg(b);
return 0;
}
算法十五 线段树
#include<iostream>
using namespace std;
long long a,b,c;
long long dg(long long a)
{
if(a<=5)return a;
return (dg(a/2)+dg(a-a/2));
}
int main()
{
cin>>a>>b;
cout<<dg(a)+dg(b);
return 0;
}
算法十六 动态规划
#include <bits/stdc++.h>
using namespace std;
int c[1010], w[1010], dp[1010], n, m;
int main() {
n = 2; m = 2; //2个物体,背包容积2
for (int i = 1;i <= n; i++) c[1] = 1, scanf("%d", &w[i]); //设体积为1,读入价值
for (int i = 1;i <= n; i++)
for (int j = m; j >= c[i]; j--)
dp[j] = max(dp[j], dp[j - c[i]] + w[i]);
printf ("%d\n", dp[m]);
return 0;
}
算法十七 最小生成树kruskal
#include <cstdio>
#include <algorithm>
#define INF 2140000000
using namespace std;
struct tree{int x,y,t;}a[10];
bool cmp(const tree&a,const tree&b)
{
return a.t<b.t;
}
int f[11],i,j,k,n,m,x,y,t,ans;
int root(int x)
{
if (f[x]==x) return x;
f[x]=root(f[x]);
return f[x];
}
int main()
{
for(i=1;i<=10;i++)f[i]=i;
for(i=1;i<=2;i++){
scanf("%d",&a[i].t);
a[i].x=i+1;a[i].y=1;k++;
}
a[++k].x=1;a[k].y=3,a[k].t=INF;
sort(a+1,a+1+k,cmp);
for(i=1;i<=k;i++){
x=root(a[i].x);
y=root(a[i].y);
if(x!=y)f[x]=y,ans+=a[i].t;
}
printf("%d",ans);
return 0;
}
算法十八 前缀和
#include <iostream>
#include <cstdio>
using namesppace std;
int n=2,a[0x3f],f[0x3f];
int main(){
for(int i=1;i<=n;i++){
cin>>a[i];
f[i]=f[i-1]+a[i];
}
cout<<f[n]<<endl;
return 0;
}
算法十九 后缀和
#include <iostream>
#include <cstdio>
using namesppace std;
int n=2,a[0x3f],f[0x3f];
int main(){
for(int i=n;i>=1;i--){
cin>>a[i];
f[i]=f[i-1]+a[i];
}
cout<<f[n]<<endl;
return 0;
}
算法二十 prim
#include <bits/stdc++.h>
using namespace std;
int w[5][5], d[5], n = 3, ans, v[5];
void prim() {
memset(d, 0x3f, sizeof d);
memset(v, 0, sizeof v);
d[1] = 0;
for (int i = 1;i < n; i++) {
int x = 0;
for (int j = 1;j <= n; j++)
if (!v[j] && (x == 0 || d[j] < d[x])) x = j;
v[x] = 1;
for (int y = 1;y <= n; y++)
if (!v[y]) d[y] = min(d[y], w[x][y]);
}
}
int main() {
int a, b; scanf("%d%d", &a, &b);
memset(w, 0x3f, sizeof w);
w[1][2] = a; w[2][3] = b;
prim();
int ans = 0;
for (int i = 2;i <= n; i++) ans += d[i];
printf("%d\n", ans);
return 0;
}
算法二十一 位运算
#include <bits/stdc++.h>
using namespace std;
int add(int a, int b) {
if (b == 0) return a;
return add(a ^ b, (a & b) << 1);
}
int main() {
int a, b; scanf("%d%d", &a, &b);
printf("%d\n", add(a, b));
return 0;
}
算法二十二 树形dp
#include <bits/stdc++.h>
using namespace std;
int f[5], n = 3, cnt, h[5], ans, dis[5];
struct edge {
int to, next, vi;
} e[5];
void add(int u, int v, int w) {
e[cnt].to= v;
e[cnt].vi = w;
e[cnt].next = h[u];
h[u] = cnt++;
}
void dp(int u, int fa) {
for (int i = h[u]; ~i; i = e[i].next) {
int v = e[i].to;
if (v == fa) continue;
dp(v, u);
ans = max(ans, dis[v] + dis[u] + e[i].vi);
dis[u] = max(dis[u], dis[v] + e[i].vi);
}
}
int main() {
memset(h, -1, sizeof h);
int a, b; scanf("%d%d", &a, &b);
add(1, 2, a); add(2, 1, a);
add(2, 3, b); add(3, 2, b);
dp(1, 0);
printf("%d\n", ans);
return 0;
}
算法二十三 树状数组
#include<bits/stdc++.h>
using namespace std;
const int SIZE = 100010;
int a[SIZE], n = 1, m = 2;
long long c[2][SIZE], sum[SIZE];
long long ask(int k, int x) {
long long ans = 0;
for(; x ; x -= x & -x) ans += c[k][x];
return ans;
}
void add(int k,int x,int y) {
for(; x <= n; x += x & -x) c[k][x] += y;
}
int main() {
a[1] = 0;
while(m--) {
int d = 0;
scanf("%d", &d);
add(0, 1, d);
add(0, 2, -d);
add(1, 1, d);
add(1, 2, -2 * d);
}
long long ans = sum[1] + 2 * ask(0, 1) - ask(1, 1);
ans -= sum[0] + 1 * ask(0, 0) - ask(1, 0);
printf("%lld\n", ans);
return 0;
}
算法二十四 分块
#include<bits/stdc++.h>
using namespace std;
long long a[50000010], sum[50000010], add[50000010];
int L[50000010], R[50000010];
int pos[50000010];
int n = 1, m = 2, t;
void change(int l, int r, long long d) {
int p = pos[l], q = pos[r];
if (p == q) {
for (int i = l; i <= r; i++) a[i] += d;
sum[p] += d*(r - l + 1);
}
else {
for (int i = p + 1; i <= q - 1; i++) add[i] += d;
for (int i = l; i <= R[p]; i++) a[i] += d;
sum[p] += d*(R[p] - l + 1);
for (int i = L[q]; i <= r; i++) a[i] += d;
sum[q] += d*(r - L[q] + 1);
}
}
long long ask(int l, int r) {
int p = pos[l], q = pos[r];
long long ans = 0;
if (p == q) {
for (int i = l; i <= r; i++) ans += a[i];
ans += add[p] * (r - l + 1);
}
else {
for (int i = p + 1; i <= q - 1; i++)
ans += sum[i] + add[i] * (R[i] - L[i] + 1);
for (int i = l; i <= R[p]; i++) ans += a[i];
ans += add[p] * (R[p] - l + 1);
for (int i = L[q]; i <= r; i++) ans += a[i];
ans += add[q] * (r - L[q] + 1);
}
return ans;
}
int main() {
a[1] = 0;
t = sqrt(n*1.0);
for (int i = 1; i <= t; i++) {
L[i] = (i - 1)*sqrt(n*1.0) + 1;
R[i] = i*sqrt(n*1.0);
}
if (R[t] < n) t++, L[t] = R[t - 1] + 1, R[t] = n;
for (int i = 1; i <= t; i++)
for (int j = L[i]; j <= R[i]; j++) {
pos[j] = i;
sum[i] += a[j];
}
while (m--) {
int d;
scanf("%d", &d);
change(1, 1, d);
}
printf("%lld\n", ask(1, 1));
}
算法二十五 LCT
#include<bits/stdc++.h>
using namespace std;
struct node
{
int data,rev,sum;
node *son[2],*pre;
bool judge();
bool isroot();
void pushdown();
void update();
void setson(node *child,int lr);
}lct[233];
int top,a,b;
node *getnew(int x)
{
node *now=lct+ ++top;
now->data=x;
now->pre=now->son[1]=now->son[0]=lct;
now->sum=0;
now->rev=0;
return now;
}
bool node::judge()
{
return pre->son[1]==this;
}
bool node::isroot()
{
if(pre==lct)return true;
return !(pre->son[1]==this||pre->son[0]==this);
}
void node::pushdown()
{
if(this==lct||!rev)return;
swap(son[0],son[1]);
son[0]->rev^=1;
son[1]->rev^=1;
rev=0;
}
void node::update()
{
sum=son[1]->sum+son[0]->sum+data;
}
void node::setson(node *child,int lr)
{
this->pushdown();
child->pre=this;
son[lr]=child;
this->update();
}
void rotate(node *now)
{
node *father=now->pre,*grandfa=father->pre;
if(!father->isroot()) grandfa->pushdown();
father->pushdown();
now->pushdown();
int lr=now->judge();
father->setson(now->son[lr^1],lr);
if(father->isroot()) now->pre=grandfa;
else grandfa->setson(now,father->judge());
now->setson(father,lr^1);
father->update();
now->update();
if(grandfa!=lct) grandfa->update();
}
void splay(node *now)
{
if(now->isroot())return;
for(; !now->isroot(); rotate(now))
if(!now->pre->isroot())
now->judge()==now->pre->judge()?rotate(now->pre):rotate(now);
}
node *access(node *now)
{
node *last=lct;
for(; now!=lct; last=now,now=now->pre) {
splay(now);
now->setson(last,1);
}
return last;
}
void changeroot(node *now)
{
access(now)->rev^=1;
splay(now);
}
void connect(node *x,node *y)
{
changeroot(x);
x->pre=y;
access(x);
}
void cut(node *x,node *y)
{
changeroot(x);
access(y);
splay(x);
x->pushdown();
x->son[1]=y->pre=lct;
x->update();
}
int query(node *x,node *y)
{
changeroot(x);
node *now=access(y);
return now->sum;
}
int main()
{
scanf("%d%d",&a,&b);
node *A=getnew(a);
node *B=getnew(b);
connect(A,B);
cut(A,B);
connect(A,B);
printf("%d",query(A,B));
return 0;
}
算法二十六 splay
#include <bits/stdc++.h>
#define ll long long
#define N 100000
using namespace std;
int sz[N], rev[N], tag[N], sum[N], ch[N][2], fa[N], val[N];
int n, m, rt, x;
void push_up(int x){
sz[x] = sz[ch[x][0]] + sz[ch[x][1]] + 1;
sum[x] = sum[ch[x][1]] + sum[ch[x][0]] + val[x];
}
void push_down(int x){
if(rev[x]){
swap(ch[x][0], ch[x][1]);
if(ch[x][1]) rev[ch[x][1]] ^= 1;
if(ch[x][0]) rev[ch[x][0]] ^= 1;
rev[x] = 0;
}
if(tag[x]){
if(ch[x][1]) tag[ch[x][1]] += tag[x], sum[ch[x][1]] += tag[x];
if(ch[x][0]) tag[ch[x][0]] += tag[x], sum[ch[x][0]] += tag[x];
tag[x] = 0;
}
}
void rotate(int x, int &k){
int y = fa[x], z = fa[fa[x]];
int kind = ch[y][1] == x;
if(y == k) k = x;
else ch[z][ch[z][1]==y] = x;
fa[x] = z; fa[y] = x; fa[ch[x][!kind]] = y;
ch[y][kind] = ch[x][!kind]; ch[x][!kind] = y;
push_up(y); push_up(x);
}
void splay(int x, int &k){
while(x != k){
int y = fa[x], z = fa[fa[x]];
if(y != k) if(ch[y][1] == x ^ ch[z][1] == y) rotate(x, k);
else rotate(y, k);
rotate(x, k);
}
}
int kth(int x, int k){
push_down(x);
int r = sz[ch[x][0]]+1;
if(k == r) return x;
if(k < r) return kth(ch[x][0], k);
else return kth(ch[x][1], k-r);
}
void split(int l, int r){
int x = kth(rt, l), y = kth(rt, r+2);
splay(x, rt); splay(y, ch[rt][1]);
}
void rever(int l, int r){
split(l, r);
rev[ch[ch[rt][1]][0]] ^= 1;
}
void add(int l, int r, int v){
split(l, r);
tag[ch[ch[rt][1]][0]] += v;
val[ch[ch[rt][1]][0]] += v;
push_up(ch[ch[rt][1]][0]);
}
int build(int l, int r, int f){
if(l > r) return 0;
if(l == r){
fa[l] = f;
sz[l] = 1;
return l;
}
int mid = l + r >> 1;
ch[mid][0] = build(l, mid-1, mid);
ch[mid][1] = build(mid+1, r, mid);
fa[mid] = f;
push_up(mid);
return mid;
}
int asksum(int l, int r){
split(l, r);
return sum[ch[ch[rt][1]][0]];
}
int main(){
//总共两个数
n = 2;
rt = build(1, n+2, 0);//建树
for(int i = 1; i <= n; i++){
scanf("%d", &x);
add(i, i, x);//区间加
}
rever(1, n);//区间翻转
printf("%d\n", asksum(1, n));//区间求和
return 0;
}
算法二十七 LCA
#include<cstdio> //头文件
#define NI 2
//从来不喜欢算log所以一般用常数 不知道算不算坏习惯 因为3个节点 所以log3(当然以2为底)上取整得2
struct edge
{
int to,next,data; //分别表示边的终点,下一条边的编号和边的权值
}e[30]; //邻接表,点少边少开30是为了浪啊
int v[10],d[10],lca[10][NI+1],f[10][NI+1],tot=0; //数组开到10依然为了浪
//数组还解释嘛,v表示第一条边在邻接表中的编号,d是深度,lca[x][i]表示x向上跳2^i的节点,f[x][i]表示x向上跳2^i的距离和
void build(int x,int y,int z) //建边
{
e[++tot].to=y; e[tot].data=z; e[tot].next=v[x]; v[x]=tot;
e[++tot].to=x; e[tot].data=z; e[tot].next=v[y]; v[y]=tot;
}
void dfs(int x) //递归建树
{
for(int i=1;i<=NI;i++) //懒,所以常数懒得优化
f[x][i]=f[x][i-1]+f[lca[x][i-1]][i-1],
lca[x][i]=lca[lca[x][i-1]][i-1]; //建树的同时进行预处理
for(int i=v[x];i;i=e[i].next) //遍历每个连接的点
{
int y=e[i].to;
if(lca[x][0]==y) continue;
lca[y][0]=x; //小技巧:lca[x][0]即为x的父亲~~(向上跳2^0=1不就是父节点嘛)
f[y][0]=e[i].data;
d[y]=d[x]+1;
dfs(y); //再以这个节点为根建子树【这里真的用得到嘛??】
}
}
int ask(int x,int y) //询问,也是关键
{
if(d[x]<d[y]) {int t=x;x=y;y=t;} //把x搞成深的点
int k=d[x]-d[y],ans=0;
for(int i=0;i<=NI;i++)
if(k&(1<<i)) //若能跳就把x跳一跳
ans+=f[x][i], //更新信息
x=lca[x][i];
for(int i=NI;i>=0;i--) //不知道能不能正着循环,好像倒着优,反正记得倒着就好了
if(lca[x][i]!=lca[y][i]) //如果x跳2^i和y跳2^j没跳到一起就让他们跳
ans+=f[x][i]+f[y][i],
x=lca[x][i],y=lca[y][i];
return ans+f[x][0]+f[y][0]; //跳到LCA上去(每步跳的时候都要更新信息,而且要在跳之前更新信息哦~)
}
int main()
{
int a,b;
scanf("%d%d",&a,&b);
build(1,2,a);
build(1,3,b); //分别建1 2、1 3之间的边
dfs(1); //以1为根建树
printf("%d",ask(2,3)); //求解2 3到它们的LCA的距离和并输出
}
算法二十八 Bellman-Ford
#include <bits/stdc++.h>
using namespace std;
int dis[50], u[50], v[50], w[50], n, m;
void bellman(int start) {
for (int i = 1;i <= n; i++) dis[i] = 0x3f3f3f3f;
dis[start] = 0;
for (int i = 1;i < n; i++)
for (int j = 1;j <= m; j++)
if (dis[v[j]] > dis[u[j]] + w[j]) dis[v[j]] = dis[u[j]] + w[j];
}
int main() {
n = 3; m = 2;
for (int i = 1;i <= m; i++) cin >> w[i], u[i] = i, v[i] = i + 1;
bellman(1);
printf("%d\n", dis[3]);
return 0;
}
算法二十九 打表
#include <bits/stdc++.h>
using namespace std;
int a, b; int main() {
scanf("%d%d", &a, &b);
if (a == 3 && b == 4) printf("7");
if (a == 45 && b == 55) printf("100");
if (a == 123 && b == 321) printf("444");
if (a == 91086199 && b == 18700332) printf("109786531");
if (a == 42267194 && b == 60645282) printf("102912476");
if (a == 69274392 && b == 10635835) printf("79910227");
if (a == 5710219 && b == 85140568) printf("90850787");
if (a == 75601477 && b == 24005804) printf("99607281");
if (a == 70597795 && b == 90383234) printf("160981029");
if (a == 82574652 && b == 22252146) printf("104826798");
return 0; //hh,这个len没加上return 0,还是我加的……
}
算法三十 只用一个变量跑a + b
#include<iostream>
using namespace std;
long long a;
int main() {
scanf("%d%d", (int*)(&a), (int*)(&a+1));
printf("%d\n", *((int*)&a) + *((int*)(&a+1)));
return 0;
}
算法三十三 矩阵乘法
#include<bits/stdc++.h>
using namespace std;
int a, b;
int x[2][2] = {
{0, 1},
{1, 1}
};
void mo(int f[]) {
int ans[2] = {0};
for(int i = 0; i < 2; i++)
for(int j = 0; j < 2; j++) ans[i] += f[j] * x[i][j];
for(int i = 0; i < 2; i++) f[i] = ans[i];
}
int main() {
cin >> a >> b;
int f[3] = {a, b};
mo(f);
cout << f[1];
return 0;
}
算法三十一 define 大法
#include <bits/stdc++.h>
#define ___ int
#define $$$ main
#define _$_$_ return
#define _ cin
#define $ cout
#define __ using
#define $$ namespace
#define o_o std
__ $$ o_o;
___ $$$(){
___ _$o$_,$o_o$;
_ >> _$o$_ >> $o_o$;
$ << _$o$_ + $o_o$;
_$_$_ 0;
}
算法三十二 拖延时间
#include <algorithm>
//STL 通用算法
#include <bitset>
//STL 位集容器
#include <cctype>
//字符处理
#include <cerrno>
//定义错误码
#include <cfloat>
//浮点数处理
#include <ciso646>
//对应各种运算符的宏
#include <climits>
//定义各种数据类型最值的常量
#include <clocale>
//定义本地化函数
#include <cmath>
//定义数学函数
#include <complex>
//复数类
#include <csignal>
//信号机制支持
#include <csetjmp>
//异常处理支持
#include <cstdarg>
//不定参数列表支持
#include <cstddef>
//常用常量
#include <cstdio>
//定义输入/输出函数
#include <cstdlib>
//定义杂项函数及内存分配函数
#include <cstring>
//字符串处理
#include <ctime>
//定义关于时间的函数
#include <cwchar>
//宽字符处理及输入/输出
#include <cwctype>
//宽字符分类
#include <deque>
//STL 双端队列容器
#include <exception>
//异常处理类
#include <fstream>
//文件输入/输出
#include <functional>
//STL 定义运算函数(代替运算符)
#include <limits>
//定义各种数据类型最值常量
#include <list>
//STL 线性列表容器
#include <locale>
//本地化特定信息
#include <map>
//STL 映射容器
#include <memory>
//STL通过分配器进行的内存分配
#include <new>
//动态内存分配
#include <numeric>
//STL常用的数字操作
#include <iomanip>
//参数化输入/输出
#include <ios>
//基本输入/输出支持
#include <iosfwd>
//输入/输出系统使用的前置声明
#include <iostream>
//数据流输入/输出
#include <istream>
//基本输入流
#include <iterator>
//STL迭代器
#include <ostream>
//基本输出流
#include <queue>
//STL 队列容器
#include <set>
//STL 集合容器
#include <sstream>
//基于字符串的流
#include <stack>
//STL 堆栈容器
#include <stdexcept>
//标准异常类
#include <streambuf>
//底层输入/输出支持
#include <string>
//字符串类
#include <typeinfo>
//运行期间类型信息
#include <utility>
//STL 通用模板类
#include <valarray>
//对包含值的数组的操作
#include <vector>
//STL 动态数组容器
//头文件拖延编译时间(虽然不能拖延运行时间,但能拖一点编译时间也很不错了hh)
using namespace std;
int main(){
int a; int b; //不用int a, b;,拖延运行时间
cin >> a >> b; //cin拖延运行时间
int ans = 1 * 10000 / 10 / 10 / 10 / 10 * 5 * 2 / 10 - 1; //ans表达式拖延编译和运行时间
for (int i = 1;i <= a; i++) ans += 5, ans -= 4; //拖延时间
for (int i = 1;i <= b; i++) ans += 5, ans -= 4; //拖延时间
ans = ans - ans + ans + ans - ans; //表达式拖延时间
cout << ans << endl; //cout和多输出回车拖延时间
return 0;
}
算法三十三 拖延时间2
#include <bits/stdc++.h>
using namespace std;
int st = clock();
int main() {
int a, b; scanf("%d%d", &a, &b);
while (clock() - st < 995000) {}
printf("%d", a + b);
return 0;
}
算法三十四 快读快写
#include<bits/stdc++.h>
using namespace std;
int read() {
int s = 0, f = 1;
char ch = getchar();
while(!isdigit(ch)) {
if(ch == '-') f = -1;
ch = getchar();
}
while(isdigit(ch)) {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * f;
}
void write(int x) {
if(x < 0) {
putchar('-');
x = -x;
}
if(x > 9) write(x / 10);
putchar(x % 10 + '0');
return;
}
int main() {
int a, b; a = read(); b = read();
write(a + b);
return 0;
}
算法三十五 sort
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e8 + 10;
int n, a[MAXN];
int main(){
n = 2;
for (int i = 1;i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
int ans = 0;
for (int i = 1;i <= n; i++) ans += a[i]; printf("%d", ans);
return 0;
}
算法三十六 冒泡排序
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e8 + 10;
int a[MAXN], n;
int main(){
n = 2;
for (int i = 1;i <= n; i++) scanf("%d", &a[i]);
for (int i = n;i > 1; i--)
for(int j = 1;j < i; j++)
if(a[j] > a[j + 1]) swap(a[j], a[j + 1]);
int ans = 0;
for (int i = 1;i <= n; i++) ans += a[i]; printf("%d", ans);
return 0;
}
算法三十七 选择排序
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e8 + 10;
int a[MAXN], n;
int main(){
n = 2;
for (int i = 1;i <= n; i++) scanf("%d", &a[i]);
for (int i = 1;i < n; i++) {
int w = i, Min = a[i];
for (int j = i;j <= n; j++) if(Min > a[j]) w = j, Min = a[j]; //寻找🔎最小数和它的位置
swap(a[i], a[w]);
}
int ans = 0;
for (int i = 1;i <= n; i++) ans += a[i]; printf("%d", ans);
return 0;
}
算法三十八 插入排序
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e8 + 10;
int a[MAXN], n;
int main(){
n = 2;
for (int i = 1;i <= n; i++) {
scanf("%d", &a[i]); int x = i - 1;
while(a[x] > a[x + 1] && x > 0) swap(a[x], a[x + 1]), x--;
}
int ans = 0;
for (int i = 1;i <= n; i++) ans += a[i]; printf("%d", ans);
return 0;
}
算法三十九 树的直径——BFS
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int head[maxn * 2],edge[maxn * 2],Next[maxn * 2],ver[maxn * 2];
int vis[maxn], dist[maxn];
int n = 3, p, q, d;
int tot = 0;
int maxd = 0;
void add(int u,int v,int w) {
ver[ ++ tot] = v,edge[tot] = w;
Next[tot] = head[u],head[u] = tot;
}
int BFS(int u) {
queue<int>Q;
while(!Q.empty()) Q.pop();
memset(vis, 0, sizeof vis);
memset(dist, 0, sizeof dist);
Q.push(u);
int x, max_num = 0;
while(!Q.empty()) {
x = Q.front();
Q.pop();
vis[x] = 1;
for(int i = head[x]; i ; i = Next[i]) {
int y = ver[i];
if(vis[y]) continue;
vis[y] = 1;
dist[y] = dist[x] + edge[i];
if(dist[y] > maxd) {
maxd = dist[y];
max_num = y;
}
Q.push(y);
}
}
return max_num;
}
int main(void) {
int a, b; scanf("%d%d", &a, &b);
add(1, 2, a); add(2, 1, a);
add(2, 3, b); add(3, 2, b);
BFS(BFS(1));
int ans = 0;
for (int i = 1;i <= n; i++) ans = max(ans, dist[i]);
printf("%d\n", ans);
return 0;
}
算法四十 树的直径——DFS
#include<bits/stdc++.h>
#define maxn 100000
using namespace std;
struct node {
int u, v, w, nex;
} edge[2 * maxn + 10];
int n = 3, d[maxn + 10], head[maxn + 10], f_num, cnt = 0, ans;
inline void add(int x,int y,int z) {
edge[++cnt].u = x;
edge[cnt].v = y;
edge[cnt].w = z;
edge[cnt].nex = head[x];
head[x] = cnt;
}
inline void dfs(int x, int fa) {
if(ans < d[x]) {
ans = d[x];
f_num = x;
}
for (int i = head[x]; i != -1; i = edge[i].nex) {
int j = edge[i].v;
if (j == fa)continue;
d[j] = d[x] + edge[i].w;
dfs(j, x);
}
}
int main() {
memset(head, -1, sizeof(head));
int a, b; scanf("%d%d", &a, &b);
add(1, 2, a); add(2, 1, a);
add(2, 3, b); add(3, 2, b);
dfs(1, 0);
ans = 0;
d[f_num] = 0;
dfs(f_num, 0);
for (int i = 1;i <= n; i++) ans = max(ans, d[i]);
printf("%d", ans);
return 0;
}
算法四十一 加一大堆东东~
#pragma GCC diagnostic error "-std=c++11"
#pragma GCC target("avx")
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b; scanf("%d%d", &a, &b);
printf("%d", a + b);
return 0;
}
算法四十二 矩阵DP
#include <bits/stdc++.h>
using namespace std;
int a[110][110], n = 2;
int main() {
for (int i = 1;i <= n; i++)
for (int j = 1;j <= n; j++) scanf("%d", &a[i][j]);
for (int i = 1;i <= n; i++)
for (int j = 1;j <= n; j++)
if (max(a[i - 1][j], a[i][j - 1]) > -1) a[i][j] += max(a[i - 1][j], a[i][j - 1]);
printf("%d\n", a[n][n]);
return 0;
}
算法四十三 希尔排序
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e8 + 10;
int n, a[MAXN];
int main(){
n = 2;
for (int i = 0;i < n; i++) scanf("%d", &a[i]);
for (int step = n / 2; step > 0; step /= 2)
for (int i = 0;i < step; i++)
for (int j = i + step;j < n; j += step)
if(a[j] < a[j - step]) {
int temp = a[j];
int k = j - step;
while (k >= 0 && temp < a[k]) {
swap(a[k + step], a[k]);
k -= step;
}
}
int ans = 0;
for (int i = 0;i < n; i++) ans += a[i]; printf("%d ", ans);
return 0;
}
算法四十四 归并排序
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e8 + 10;
int n, a[MAXN], T[MAXN];
void Mergesort(int l, int r) {
if (l == r) return; //区间内只有一个数,返回
int mid = l + r >> 1; //相当于(l + r) / 2
Mergesort(l, mid); //递归左半部分
Mergesort(mid + 1, r); //递归右半部分
int i = l, j = mid + 1, k = l;
while (i <= mid && j <= r) //合并
if (a[i] <= a[j]) T[k++] = a[i++];
else T[k++] = a[j++];
while (i <= mid) T[k++] = a[i++];
while (j <= r) T[k++] = a[j++];
for (int q = l; q <= r; q++) a[q] = T[q]; //转移
}
int main() {
n = 2;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
Mergesort(1, n);
int ans = 0;
for (int i = 1; i <= n; i++) ans += a[i]; printf("%d", ans);
return 0;
}
算法四十五 快速排序
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e8 + 10;
int n, a[MAXN];
void quickSort(int l, int r) {
if (l >= r) return;
int i = l, j = r, base = a[l]; //base取最左边的数为基准数
while(i < j) {
while (a[j] >= base && i < j) j--;
while (a[i] <= base && i < j) i++;
if (i < j) swap(a[i], a[j]);
}
a[l] = a[i]; a[i] = base; //基准数归位
quickSort (l, i - 1); //递归左边
quickSort (i + 1, r); //递归右边
}
int main() {
n = 2;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
quickSort(1, n);
int ans = 0;
for (int i = 1; i <= n; i++) ans += a[i]; printf("%d", ans);
return 0;
}
算法四十六 堆排序
#include <bits/stdc++.h>
using namespace std;
int n;
const int MAXN = 1e8 + 10;
int h[MAXN], s;
void down(int u) {
int t = u; // t记录最小值
if (2 * u <= s && h[2 * u] < h[t]) t = 2 * u; // 左儿子
if (2 * u + 1 <= s && h[2 * u + 1] < h[t]) t = 2 * u + 1; // 右儿子
if (t != u) { //需要调整
swap(h[t], h[u]);
down(t); //递归
}
}
int main() {
n = 2;
for (int i = 1; i <= n; i ++) scanf("%d", &h[i]);
s = n;
for (int i = n / 2; i >= 1; i--) down(i); //初始化堆j
int ans = 0;
while (n--) {
ans += h[1];
h[1] = h[s]; s--;
down(1);
}
printf("%d", ans);
return 0;
}
算法四十七 计数排序
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e8 + 10;
long long n, cnt[MAXN];
int main() {
n = 2; int x = 0, Max = -0x3f3f3f, Min = 0x3f3f3f; //初始化最大值和最小值
for (int i = 1; i <= n; i ++) {
scanf("%d", &x); cnt[x]++; //统计
Max = max(Max, x); Min = min(Min, x); //更新最大值和最小值
}
int ans = 0;
for (int i = Min;i <= Max; i++)
while(cnt[i]) cnt[i]--, ans += i;
printf("%d", ans);
return 0;
}
算法四十八 桶排序
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e8 + 10;
int n, Min = MAXN, Max = 0, sum[MAXN], ans;
bool f[45];
vector<int> bucket[45];//定义桶,这里定义40个桶
void insertsort(int s) {
for (int i = 0;i < bucket[s].size(); i++)
for (int j = i;j >= 1; j--) if(bucket[s][j - 1] > bucket[s][j]) swap(bucket[s][j], bucket[s][j - 1]);//这里是从小到大排序
for (int i = 0;i < bucket[s].size(); i++) ans += bucket[s][i];
}
void bucketsort() {
for (int i = 1;i <= n; i++)
bucket[int((sum[i] - Min) / ((Max - Min + 1) / 40.0))].push_back(sum[i]), f[int((sum[i] - Min) / ((Max - Min + 1) / 40.0))] = 1;//运用最大最小值来合理分配桶
for (int i = 0;i <= 40; i++) if(f[i]) insertsort(i); //如果当前桶有数值,则对桶内的数进行排序(这里用选择排序)
}
int main() {
n = 2;
for (int i = 1;i <= n; i++) {
scanf("%d", &sum[i]);
Min = min(Min, sum[i]), Max = max(Max, sum[i]); //为了能够合理利用空间,确保第一个桶和最后一个桶都有数,所以存储最大最小值
}
bucketsort(); printf("%d", ans);
return 0;
}
算法四十九 基数排序
#include <bits/stdc++.h>
using namespace std;
int maxbit(int data[], int n) {
int d = 1, p = 10; //d保存最大的位数
for (int i = 0;i < n; i++) while(data[i] >= p) p *= 10, d++;
return d;
}
void radixsort(int data[], int n) { //基数排序
int d = maxbit(data, n);
int tmp[n];
int cnt[15], i, j, k, radix = 1;
for (i = 1;i <= d; i++) { //进行d次排序
memset(cnt, 0, sizeof(cnt)); //清空计数器
for (j = 0;j < n; j++) {
k = (data[j] / radix) % 10;
cnt[k]++;
}
for (j = 1;j < 10; j++) cnt[j] += cnt[j - 1];
for (j = n - 1;j >= 0; j--) {
k = (data[j] / radix) % 10;
tmp[cnt[k] - 1] = data[j];
cnt[k]--;
}
for (j = 0;j < n; j++) data[j] = tmp[j];
radix *= 10;
}
}
const int MAXN = 1e8 + 10;
int n, a[MAXN];
int main(){
n = 2;
for (int i = 0;i < n; i++) scanf("%d", &a[i]);
radixsort(a, n);
int ans = 0;
for (int i = 0;i < n; i++) ans += a[i]; printf("%d", ans);
}
算法五十 鸡尾酒排序
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e8 + 10;
int n, a[MAXN];
int main() {
n = 2;
for (int i = 1;i <= n; i++) scanf("%d", &a[i]);
int cnt = 0;
while (1) {
int f = 0; cnt++;
if(cnt & 1)
for (int i = 1;i < n; i++) if(a[i] > a[i + 1]) swap(a[i], a[i + 1]), f = 1;
else
for (int i = n;i > 1; i--) if(a[i] < a[i - 1]) swap(a[i], a[i - 1]), f = 1;
if(!f) break;
}
int ans = 0;
for (int i = 1;i <= n; i++) ans += a[i]; printf("%d", ans);
return 0;
}
算法五十一 二叉树排序
#include<bits/stdc++.h>
#define LL long long
#define INF 0x7FFFFFFF
using namespace std;
const int N = 1e8 + 10;
int n, idx, rt, ans;
int a[N], t[N];
int ch[N][2];
void insert(int &x, int val) {
if (!x) {
x = ++ idx;
t[x] = val;
return;
}
else {
if(val < t[x]) insert(ch[x][0], val);
else insert(ch[x][1], val);
}
}
void dfs(int x) { //中序遍历二叉排序树
if(!x) return;
dfs(ch[x][0]);
ans += t[x];
dfs(ch[x][1]);
}
int main() {
n = 2;
for (int i = 1;i <= n; i++) scanf("%d", &a[i]);
for (int i = 1;i <= n; i++) insert(rt, a[i]);
dfs(rt); printf("%d", ans);
return 0;
}
算法五十二 侏儒排序
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e8 + 10;
int n, a[MAXN];
int main() {
n = 2;
for (int i = 1;i <= n; i++) scanf("%d", &a[i]);
int s = 1;
while(s <= n) {
if(a[s - 1] <= a[s] || s == 0) s++;
else swap(a[s], a[s - 1]), s--;
}
int ans = 0;
for (int i = 1;i <= n; i++) ans += a[i]; printf("%d", ans);
return 0;
}
算法五十三 猴子排序
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e8 + 10;
int n, a[MAXN];
int check() {
for (int i = 1;i < n; i++) if(a[i] > a[i + 1]) return 0;
return 1;
}
int main() {
n = 2;
for (int i = 1;i <= n; i++) scanf("%d", &a[i]);
while (1) {
random_shuffle(a + 1, a + 1 + n); //随机打乱数组的系统函数
if(check()) break;
}
int ans = 0;
for (int i = 1;i <= n; i++) ans += a[i]; printf("%d", ans);
return 0;
}
算法五十四 快速幂
#include<bits/stdc++.h>
using namespace std;
int qmi(int m, int k, int p) {
int res = 1 % p, t = m;
while (k) {
if (k & 1) res = res * t % p;
t = t * t % p;
k >>= 1;
}
return res;
}
int main() {
int a, b; scanf("%d%d", &a, &b);
printf("%d", qmi(a, 1, 100000010) + qmi(b, 1, 100000010));
return 0;
}
算法五十五 二进制
#include<bits/stdc++.h>
using namespace std;
int a, b, s, s1, i, na, nb;
int main() {
scanf("%d%d", &a, &b);
if (a <= 0) na = 1, a = abs(a);
while(a) {
if ((a & 1) != 0) s += pow(2, (a & 1) * i);
a >>= 1; i++;
}
i = 0;
if (na == 1) s = abs(s);
if (b <= 0) nb = 1, b = abs(b);
while(b) {
if ((b & 1) != 0) s1 += pow(2, (b & 1) * i);
b >>= 1; i++;
}
if (nb == 1) s1 = abs(s1);
printf("%d", s + s1);
return 0;
}
本次搞怪结束 你学废了吗????????
泰裤辣
!!!!!!!
但是你好像没有python
太牛了
哇
又是一个种花家的