初三高考放假做题记录part.1

最新推荐文章于 2021-07-24 00:02:34 发布
最新推荐文章于 2021-07-24 00:02:34 发布
阅读量150 收藏
点赞数
分类专栏： 自闭系列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41567618/article/details/107216644
版权

luoguP3243 [HNOI2015]菜肴制作
题意：给你一组关系，使得入点必须在出点后做掉。求最小的字典序
比较好想，先建个反图，然后用堆套上拓扑排序，实现从后往前字典序最大
等价于实现了从前往后字典序最小。。。
扩展：一些比较难搞的条件，可以尝试反转，联系类似的算法，对于题目给定的要求要进一步转化。。（需要的话），偏序关系可以往拓扑方向想

#include<bits/stdc++.h>
#define MAXN 100005
using namespace std;

int T,n,m,h[MAXN],tot,in[MAXN],rest;

struct node{
	int from,to,next;
}e[MAXN << 1];

void add(int x , int y){
	tot++;
	e[tot].from = x;
	e[tot].to = y;
	e[tot].next = h[x];
	h[x] = tot;
}

void init(){
	memset(in , 0 , sizeof(in));
	memset(h , -1 , sizeof(h));
	cin>>n>>m;int x,y;tot = 0;rest = n;
	for(int i = 1 ; i <= m ; i++){
		cin>>x>>y;
		in[x]++;
		add(y , x);
	}
}
stack<int>ans;
void solve(){
	 priority_queue<int> q;
	for(int i = 1 ; i <= n ; i++){
		if(!in[i])q.push(i);
	}	
	int now;
	while(!q.empty()){
		now = q.top();q.pop();rest--;
		ans.push(now);
		for(int i = h[now] ; i != (-1) ; i = e[i].next){
			in[e[i].to]--;if(!in[e[i].to])q.push(e[i].to);
		}
	}
	if(rest){
		cout<<"Impossible!"<<endl;
		while(!ans.empty())ans.pop();
		return;
	}
	while(!ans.empty()){
		cout<<ans.top()<<" ";
		ans.pop();	
	}
	cout<<endl;
}

int main(){
	cin>>T;
	while(T--){
		init();
		solve();	
		
	}
}

luoguP1282 多米诺骨牌
你先把暴力写出来，发现A与B的值可以做成一个差，就可以少一维

#include<bits/stdc++.h>
#define MAXN 1005
using namespace std;

int n,a[MAXN],b[MAXN],f[1005][12005];
void init(){
	cin>>n;
	for(int i = 1 ; i <= n ; i++)cin>>a[i]>>b[i];
}

void solve(){
	memset(f , 0x3f , sizeof(f));f[0][6000] = 0;
	for(int i = 1 ; i <= n ; i++){
		for(int S = 6000 - i * 6 ; S <= 6000 + i * 6 ; S++){
			f[i][S] = min(f[i - 1][S + (a[i] - b[i])] , f[i - 1][S + (b[i] - a[i])] + 1);
		}
	}
	int ans = 9999999,minl = 9999999;
	for(int i = 0 ; i <= 12000 ; i++){
		if(f[n][i] < 1005 && abs(i - 6000) < ans){
			ans = abs(6000 - i);
			minl = f[n][i];
		}
	}
	cout<<minl<<endl;
}

int main(){
	init();
	solve();
}

luoguP1126 机器人搬重物
纯bfs。。。dfs写会t飞

#include<bits/stdc++.h>
#define MAXN 55
using namespace std;

int n,m,tu[MAXN][MAXN],BX,BY,TX,TY,BR,f[MAXN][MAXN][5];
int dx[4] = {-1 , 0, 1 , 0};
int dy[4] = {0 , -1 , 0 , 1};
struct node{
	int x,y,r;
};
queue<node>q;

int check(int nowx , int nowy){
	if(tu[nowx - 1][nowy - 1] == 1 || tu[nowx - 1][nowy] == 1)return 2;
	if(tu[nowx][nowy - 1] == 1 || tu[nowx][nowy] == 1)return 2;
	return 1;
}


void init(){
	memset(f , 0x3f , sizeof(f));
	cin>>n>>m;
	for(int i = 1 ; i <= n ; i++)for(int j = 1 ; j <= m ; j++)cin>>tu[i][j];
	char R;cin>>BX>>BY>>TX>>TY>>R;
	BX++ , BY++ , TX++ , TY++ , n++ , m++;
	if(R == 'N')BR = 0;
	if(R == 'S')BR = 2;
	if(R == 'W')BR = 1;
	if(R == 'E')BR = 3;
	f[BX][BY][BR] = 0;
	q.push((node){BX , BY , BR});
}

int zzx,zzy;
void bfs(){
	node now;
	while(!q.empty()){
		now = q.front() , q.pop();
		for(int i = 1 ; i <= 3; i++){
			zzx = now.x + dx[now.r] * i;
			zzy = now.y + dy[now.r] * i;
			if(check(zzx , zzy) != 1)break; 
			if(min(zzx , zzy) < 2)break;
			if(zzx >= n || zzy >= m)break;
			if(f[zzx][zzy][now.r] < f[now.x][now.y][now.r] + 1)continue;
			f[zzx][zzy][now.r] = f[now.x][now.y][now.r] + 1;
			q.push((node){zzx , zzy , now.r});
		}
		if(f[now.x][now.y][(now.r + 1) % 4] > f[now.x][now.y][now.r] + 1){
			f[now.x][now.y][(now.r + 1) % 4] = f[now.x][now.y][now.r] + 1;
			q.push((node){now.x , now.y , (now.r + 1) % 4});
		}
		if(f[now.x][now.y][((now.r - 1) % 4 + 4) % 4] > f[now.x][now.y][now.r] + 1){
			f[now.x][now.y][((now.r - 1) % 4 + 4) % 4] = f[now.x][now.y][now.r] + 1;
			q.push((node){now.x , now.y , ((now.r - 1) % 4 + 4) % 4});
		}	
	}
	int ans = 999999;
	for(int i = 0 ; i < 4 ; i++)ans = min(ans , f[TX][TY][i]);
	if(ans == 999999)cout<<-1<<endl;
	else cout<<ans<<endl;
}

int main(){
	init();
	bfs();
}

luoguP1168 中位数
一个比较重要的技巧，用一个对顶堆动态维护中位数，使得这两个堆大小不超过。。
或者拿主席树或者一些奇奇怪怪的数据结构也可以做

#include<bits/stdc++.h>
#define MAXN 100005
typedef long long ll;
using namespace std;

ll n,a[MAXN],zz,zz2;

priority_queue<ll> q;
priority_queue <ll,vector<ll>,greater<ll> > q2;

void init(){
	cin>>n;
	for(int i = 1 ; i <= n ; i++)cin>>a[i];
	q.push(a[1]);
	cout<<a[1]<<endl;
}

void solve(){
	for(int i = 2 ; i <= n ; i++){
		if(q.top() > a[i])q.push(a[i]);
		else q2.push(a[i]);
		zz = q.size() , zz2 = q2.size();
		while(abs(zz - zz2) > 1){
			if(zz > zz2)q2.push(q.top()) , q.pop();
			else q.push(q2.top()) , q2.pop();
			zz = q.size() , zz2 = q2.size();
		}
		if(i % 2 == 1)cout<<(q.size() > q2.size() ? q.top() : q2.top())<<endl;
	}
}

int main(){
	init();
	solve();
}

luoguP5201 [USACO19JAN]Shortcut G
奶牛屑题，考虑先建一颗最小字典序的最短距离生成树
然后直接跑就行了

#include<bits/stdc++.h>
#define MAXN 50005
typedef long long ll;
using namespace std;

ll n,m,T,h[MAXN][2],c[MAXN],tot[2],dis[MAXN],vis[MAXN],sum[MAXN],ans;
queue<ll>q;
struct node{
	ll from,to,cost,next,full;
}e[MAXN << 1][2];

void add(int x , int y , ll z , int k){
	tot[k]++;
	e[tot[k]][k].from = x;
	e[tot[k]][k].to = y;
	e[tot[k]][k].cost = z;
	e[tot[k]][k].next = h[x][k];
	h[x][k] = tot[k];
}

void init(){
	memset(vis , -1 , sizeof(vis));
	memset(dis , 0x3f , sizeof(dis));
	memset(h , -1 , sizeof(h));
	tot[0] = tot[1] = 0;
	cin>>n>>m>>T;ll x,y,z;
	for(int i = 1 ; i <= n ; i++)cin>>c[i];
	for(int i = 1 ; i <= m ; i++){
		cin>>x>>y>>z;
		add(x , y , z , 0);
		add(y , x , z , 0);
	}
}

int dfs(int now , int fa){
	for(int i = h[now][1] ; i != (-1) ; i = e[i][1].next){
		if(e[i][1].to == fa)continue;
		dfs(e[i][1].to , now);
		e[i][1].full = c[e[i][1].to];
		c[now] += c[e[i][1].to];
	}
}

void solve(){
	ll now;
	q.push(1);dis[1] = 0;vis[1] = 1;
	while(!q.empty()){
		now = q.front();vis[now] = (-1);q.pop();
		for(int i = h[now][0] ; i != (-1) ; i = e[i][0].next){
			if(dis[e[i][0].to] > dis[now] + e[i][0].cost){
				dis[e[i][0].to] = dis[now] + e[i][0].cost;
				if(vis[e[i][0].to] == (-1))q.push(e[i][0].to) , vis[e[i][0].to] = 1;
			}
		}
	}
	ll zz;
	for(int i = 2 ; i <= n ; i++){
		zz = 999999;
		for(int j = h[i][0] ; j != (-1) ; j = e[j][0].next){
			if(dis[e[j][0].to] + e[j][0].cost == dis[i]){
				if(zz == 999999)zz = j;
				else if(e[zz][0].to > e[j][0].to)zz = j;
			}
		}
		add(i , e[zz][0].to , e[zz][0].cost , 1);
		add(e[zz][0].to , i , e[zz][0].cost , 1);
	}
	dfs(1 , 1);
	for(int i = 1 ; i <= n ; i++){
		ans = max(ans , (dis[i] - T) * c[i]);
	}
	cout<<ans<<endl;
}

int main(){
	init();
	solve();
}

luoguP5196 [USACO19JAN]Cow Poetry G
先算出长度为n的字符串组成的方案
——>>>得到了以那个字符串结尾的诗句的方案数
——>>>得到了以那个韵部结尾的方案数
然后这题其实就结束了

#include<bits/stdc++.h>
#define MAXN 5005
typedef long long ll;
using namespace std;
ll mod = 1000000007;
ll n,m,k,s[MAXN],c[MAXN],f[100005],num[MAXN],tp[100005],ans,tot,p[MAXN];

ll poww(ll x , ll y){
	ll zz = 1;
	while(y){
		if(y & 1)zz = (zz * x) % mod;
		x = (x * x) % mod;
		y = y >> 1;
	}
	return zz % mod;
}

void init(){
	cin>>n>>m>>k;char zz;f[0] = ans = 1;
	for(int i = 1 ; i <= n ; i++)cin>>s[i]>>c[i];
	for(int i = 1 ; i <= m ; i++)cin>>zz , num[zz - 'A' + 1]++;
}

void solve(){
	for(int i = 1 ; i <= k ; i++)for(int j = 1 ; j <= n ; j++)
	if(i >= s[j])f[i] = (f[i] + f[i - s[j]]) % mod;
	for(int i = 1 ; i <= n ; i++)tp[c[i]] = (tp[c[i]] + f[k - s[i]]) % mod;
	for(int i = 1 ; i <= 26 ; i++){
		if(!num[i])continue;
		++tot;
		for(int j = 1 ; j <= n ; j++){
			if(!tp[j])continue;
			p[tot] = (p[tot] + poww(tp[j] , num[i])) % mod;
		}
	}
	for(int i = 1 ; i <= tot ; i++)ans = (ans * p[i]) % mod;
	cout<<ans<<endl;
}

int main(){
	init();
	solve();
}

luoguP5199 [USACO19JAN]Mountain View S
有个很妙的定理，当前等腰直角三角形到x轴的投影可以决定这个等腰直角三角形的顶点是否被包含

自证不难

#include<bits/stdc++.h>
#define MAXN 100005
typedef long long ll;
using namespace std;

ll n,x,y,ans;

struct node{
	ll l,r;
}t[MAXN];

bool cmp(node a , node b){
	if(a.l == b.l)return a.r > b.r;
	else return a.l < b.l;
}

void init(){
	cin>>n;
	for(int i = 1 ; i <= n ; i++)cin>>x>>y , t[i].l = x - y , t[i].r = x + y;
}

void solve(){
	sort(t + 1 , t + 1 + n , cmp);
	ll now = -99999999999;
	for(int i = 1 ; i <= n ; i++){
		if(t[i].r > now)now = t[i].r , ans++;
	}
	cout<<ans<<endl;
}

int main(){
	init();
	solve();
}

luoguP3390 【模板】矩阵快速幂
看了点线性代数之后，这个东西就比较好理解了
初始话就用 E E E去成，一样的。
但矩阵乘法没交交换律，故要小心写错

#include<bits/stdc++.h>
#define MAXN 105
typedef long long ll;
using namespace std;

ll n,k,mod = 1000000007;

struct node{
	ll a[105][105]; 
}A,B;


node operator * (node x , node y){
	node z;
	for(int i = 1 ; i <= n ; i++)for(int j = 1 ; j <= n ; j++)z.a[i][j] = 0;
	for(int i = 1 ; i <= n ; i++){
		for(int j = 1 ; j <= n ; j++){
			for(int k = 1 ; k <= n ; k++){
				z.a[i][j] = (z.a[i][j] + x.a[i][k] * y.a[k][j]) % mod;	
			}
		}
	}
	return z;
}

int main(){
	cin>>n>>k;
	for(int i = 1 ; i <= n ; i++)for(int j = 1 ; j <= n ; j++)cin>>A.a[i][j];
	for(int i = 1 ; i <= n ; i++)B.a[i][i] = 1;
	while(k){
		if(k & 1)B = B * A;
		A = A * A;
		k = k >> 1;
	}
	for(int i = 1 ; i <= n ; i++){
		for(int j = 1 ; j <= n ; j++){
			cout<<B.a[i][j]<<" ";	
		}	
		cout<<endl;
	}
}

luoguP3806 【模板】点分治1
嘛，这个东西就是一个假的暴力，，，
总划分重心的复杂度是 O ( n l o g n ) O(nlogn) O(nlogn)的
一般这上面的操作有两种
1.不用桶的，那种值域很大的
2.用桶的，值域很小
注意，这个东西，我只会处理那种跟路径有关的问题。。
跟子树一些特征之类的还没遇到过

#include<bits/stdc++.h>
#define MAXN 80005
typedef long long ll;
using namespace std;

int n,m,k,h[MAXN],tot,vis[MAXN],sz[MAXN],zhong[MAXN],maxl,ask[MAXN],ans[MAXN];
int dis[MAXN],js,dui[MAXN],in[40000005],jjs;

struct node{
	int from,to,nex,cost;
}e[MAXN << 1];

void add(int x , int y , int z){
	tot++;
	e[tot].from = x;
	e[tot].to = y;
	e[tot].cost = z;
	e[tot].nex = h[x];
	h[x] = tot;
	return;
}

void getsz(int now , int fa){
	sz[now] = 1;
	for(int i = h[now] ; i != (-1) ; i = e[i].nex){
		if(e[i].to == fa || vis[e[i].to])continue;
		getsz(e[i].to , now);
		sz[now] += sz[e[i].to];
	}
	return;
}

void getzx(int now , int fa , int yl){
	zhong[now] = 0;
	for(int i = h[now] ; i != (-1) ; i = e[i].nex){
		if(e[i].to == fa || vis[e[i].to])continue;
		getzx(e[i].to , now , yl);
		if(sz[zhong[now]] < sz[e[i].to])zhong[now] = e[i].to;
	}
	zhong[now] = max(sz[zhong[now]] , sz[yl] - sz[zhong[now]]);
	if(zhong[now] < zhong[maxl])maxl = now;
	return;
}

void getdis(int now , int fa){
	for(int i = h[now] ; i != (-1) ; i = e[i].nex){
		if(e[i].to == fa || vis[e[i].to])continue;
		dis[e[i].to] = dis[now] + e[i].cost;
		getdis(e[i].to , now);
	}
	dui[++js] = dis[now];
	return;
}

void calc(int now){
	js = 0;
	for(int i = h[now] ; i != (-1) ; i = e[i].nex){
		if(vis[e[i].to])continue;
		dis[e[i].to] = e[i].cost , jjs = js;
		dui[++js] = dis[e[i].to];
		getdis(e[i].to , now);
		
		for(int i = 1 ; i <= m ; i++){
			for(int j = jjs + 1 ; j <= js ; j++){
				if(ask[i] < dui[j])continue;
				if(in[ask[i] - dui[j]])ans[i] = 1;
			}
		}
		for(int i = jjs ; i <= js ; i++)if(dui[i] <= 10000005)in[dui[i]] = 1;
	}
	for(int i = 1 ; i <= js ; i++)in[dui[i]] = 0;
	return;
}

void solve(int now){
	vis[now] = 1;
	calc(now);getsz(now , now);
	for(int i = h[maxl] ; i != (-1) ; i = e[i].nex){
		if(vis[e[i].to])continue;
		maxl = 0;getzx(e[i].to , now , e[i].to);
		solve(maxl);
	}
	return;
}

void init(){
	memset(ans , -1 , sizeof(ans));
	memset(in, 0 , sizeof(in));
	memset(h , -1 , sizeof(h));
	cin>>n>>m;
	int x,y,z;tot = 0 , sz[n + 1] = n;
	zhong[0] = 9999999;in[0] = 1;
	for(int i = 1 ; i < n ; i++){
		cin>>x>>y>>z;
		add(x , y , z);
		add(y , x , z);
	}
	for(int i = 1 ; i <= m ; i++)cin>>ask[i];
	maxl = 0;getzx(1 , 1 , n + 1);
	solve(maxl);
	for(int i = 1 ; i <= m ; i++){
		if(ans[i] == 1)cout<<"AYE"<<endl;
		else cout<<"NAY"<<endl;
	}
}



int main(){
	init();
}

luoguP4178 Tree
点分治的屑题
不过要注意，如果在分治过程中直接算会t飞，要开个桶

#include<bits/stdc++.h>
#define MAXN 80005
using namespace std;

int n,K,h[MAXN],tot,sz[MAXN],maxl[MAXN],dis[MAXN],vis[MAXN],ZX;
int dui[MAXN],js,jjs,ans[20005],sum,zzq[20005];

struct node{
	int from , to , cost , next;
}e[MAXN << 1];

void add(int x , int y , int z){
	tot++;
	e[tot].from = x;
	e[tot].to = y;
	e[tot].cost = z;
	e[tot].next = h[x];
	h[x] = tot;
}

void getsz(int now , int fa){
	sz[now] = 1;maxl[now] = 0;
	for(int i = h[now] ; i != (-1) ; i = e[i].next){
		if(e[i].to == fa || vis[e[i].to])continue;
		getsz(e[i].to , now);
		sz[now] += sz[e[i].to];
		if(sz[e[i].to] > sz[maxl[now]])maxl[now] = e[i].to;
	}
}

void getzx(int now , int fa , int yl){
	for(int i = h[now] ; i != (-1) ; i = e[i].next){
		if(e[i].to == fa || vis[e[i].to])continue;
		getzx(e[i].to , now , yl);
	}
	maxl[now] = max(sz[maxl[now]] , sz[yl] - sz[maxl[now]]);
	if(maxl[now] <= maxl[ZX])ZX = now;
}

void getdis(int now , int fa){
	for(int i = h[now] ; i != (-1) ; i = e[i].next){
		if(e[i].to == fa || vis[e[i].to])continue;
		dis[e[i].to] = dis[now] + e[i].cost;
		getdis(e[i].to , now);
	}
	if(dis[now] <= K)dui[++js] = dis[now];
}

void calc(int now){
	js = 0;
	for(int i = h[now] ; i != (-1) ; i = e[i].next){
		if(vis[e[i].to])continue;
		jjs = js;dis[e[i].to] = e[i].cost;
		getdis(e[i].to , now);
		for(int j = 1 ; j <= K ; j++){
			if(!zzq[j])continue;
			for(int k = jjs + 1 ; k <= js ; k++){
				if(j + dui[k]> K)continue;	
				ans[dui[k] + j] += zzq[j];
			}
		}
		for(int j = jjs + 1 ; j <= js ; j++)zzq[dui[j]]++;
	}
	for(int i = 1 ; i <= js ; i++)zzq[dui[i]]--;
	for(int i = 1 ; i <= js ; i++){
		if(dui[i] > K)continue;
		ans[dui[i]]++;	
	}
}

void solve(int now){
	getsz(now , now);calc(now);vis[now] = 1;
	for(int i = h[now] ; i != (-1) ; i = e[i].next){
		if(vis[e[i].to])continue;
		ZX = 0;getzx(e[i].to , now , e[i].to);
		solve(ZX);
	}
}

void init(){
	memset(h , -1 , sizeof(h));
	cin>>n;int u,v,w;maxl[0] = 9999999;
	for(int i = 1 ; i < n ; i++)cin>>u>>v>>w , add(u , v , w) , add(v , u , w);
	cin>>K;
	getsz(1 , 1);ZX = 0;
	getzx(1 , 1 , 1);
	solve(ZX);
	for(int i = 1 ; i <= K ; i++)sum = sum + ans[i];
	cout<<sum<<endl;
}

int main(){
	init();
	
}

luoguP2634 [国家集训队]聪聪可可
这个类似与上面

#include<bits/stdc++.h>
#define MAXN 50005
using namespace std;

int n,h[MAXN],tot,dis[MAXN],sz[MAXN],maxl[MAXN],ZX,vis[MAXN],a1,a2;
int dui[MAXN],js,jjs,tp[4],ans[4];

struct node{
	int from,to,cost,next;
}e[MAXN << 1];

void add(int x , int y , int z){
	tot++;
	e[tot].from = x;
	e[tot].to = y;
	e[tot].cost = z % 3;
	e[tot].next = h[x];
	h[x] = tot;
}

void getsz(int now , int fa){
	sz[now] = 1 , maxl[now] = 0;
	for(int i = h[now] ; i != (-1) ; i = e[i].next){
		if(e[i].to == fa || vis[e[i].to])continue;
		getsz(e[i].to , now);
		sz[now] += sz[e[i].to];
		if(sz[e[i].to] > sz[maxl[now]])maxl[now] = e[i].to;
	}
}

void getzx(int now , int fa , int yl){
	for(int i = h[now] ; i != (-1) ; i = e[i].next){
		if(e[i].to == fa || vis[e[i].to])continue;
		getzx(e[i].to , now , yl);
	}
	maxl[now] = max(sz[maxl[now]] , sz[yl] - sz[maxl[now]]);
	if(maxl[now] < maxl[ZX])ZX = now;
}

void getdis(int now , int fa){
	for(int i = h[now] ; i != (-1) ; i = e[i].next){
		if(e[i].to == fa || vis[e[i].to])continue;
		dis[e[i].to] = (dis[now] + e[i].cost) % 3;
		getdis(e[i].to , now);
	}
	js++;
	dui[js] = dis[now] % 3;
}

void calc(int now){
	js = 0;
	for(int i = h[now] ; i != (-1) ; i = e[i].next){
		if(vis[e[i].to])continue;
		dis[e[i].to] = e[i].cost , jjs = js;
		getdis(e[i].to , now);
		for(int j = jjs + 1 ; j <= js ; j++)for(int k = 0 ; k <= 2 ; k++)ans[(k + dui[j]) % 3] += tp[k];
		for(int j = jjs + 1 ; j <= js ; j++)tp[dui[j] % 3]++;
	}
	for(int i = 0 ; i <= 2 ; i++)ans[i] += tp[i];
	memset(tp , 0 , sizeof(tp));
}

void solve(int now){
	calc(now);vis[now] = 1;getsz(now , now);
	for(int i = h[now] ; i != (-1) ; i = e[i].next){
		if(vis[e[i].to])continue;
		ZX = 0;getzx(e[i].to , now , e[i].to);
		solve(ZX);
	}
}

void init(){
	tot = 0;
	memset(h , -1 , sizeof(h));
	cin>>n;int x,y,w;maxl[0] = 99999999;
	for(int i = 1 ; i < n ; i++){
		cin>>x>>y>>w;
		add(x , y , w);
		add(y , x , w);
	}
	getsz(1 , 1) , ZX = 0 , getzx(1 , 1 , 1);
	solve(ZX);
	ans[0] = ans[0] * 2 + n;
	a1 = ans[0] , a2 = n * n;
	for(int i = 2 ; i <= min(a1 , a2) ; i++){
		while(a1 % i == 0 && a2 % i == 0){
			a1 /= i;
			a2 /= i;
		}
	}
	cout<<a1<<"/"<<a2<<endl;
}

int main(){
	init();
}

luoguP3371 【模板】单源最短路径（弱化版）
模板题

#include<bits/stdc++.h>
typedef long long ll;
using namespace std;

ll n,m,s,h[30005],tot,vis[30005],dis[30005],op = 1;

struct node{
	ll from,to,cost,next;
}e[600005 << 1];

struct node2{
	ll num,val;
};
priority_queue<node2>q;
bool operator < (node2 x , node2 y){
	return x.val > y.val;
}

void add(ll x , ll y , ll z){
	tot++;
	e[tot].from = x;
	e[tot].to = y;
	e[tot].cost = z;
	e[tot].next = h[x];
	h[x] = tot;
}

void disjkra(ll beg){
	memset(vis , -1 , sizeof(vis));
	dis[beg] = 0;q.push((node2){beg , 0});
	node2 now;
	while(!q.empty()){
		now = q.top();q.pop();
		if(vis[now.num] == 1)continue;
		vis[now.num] = 1;
		for(int i = h[now.num] ; i != (-1) ; i = e[i].next){
			if(dis[e[i].to] > dis[now.num] + e[i].cost){
				dis[e[i].to] = dis[now.num] + e[i].cost;
				if(vis[e[i].to] == (-1))q.push((node2){e[i].to , dis[e[i].to]});
			}
		}
	}
}

void init(){
	tot = 0;memset(h , -1 , sizeof(h));
	cin>>n>>m>>s;int x,y,z;
	for(int i = 1 ; i <= 31 ; i++)op = op << 1;
	op--;
	for(int i = 1 ; i <= n ; i++)dis[i] = op;
	for(int i = 1 ; i <= m ; i++){
		cin>>x>>y>>z;
		add(x , y , z);
	}
	disjkra(s);
	for(int i = 1 ; i <= n ; i++){
		cout<<dis[i]<<" ";
	}
}

int main(){
	init();
}

luoguP3385 【模板】负环
有两种判别方法
1.收缩次数大于n
2.距离起点距离大于n

#include<bits/stdc++.h>
#define MAXN 30005
typedef long long ll;
using namespace std;

int T,n,m,h[MAXN],tot,dis[MAXN],vis[MAXN],cnt[MAXN];

struct node{
	int from,to,cost,next;
}e[MAXN << 1];

queue<int>q;

void add(int x , int y , int z){
	tot++;
	e[tot].from = x;
	e[tot].to = y;
	e[tot].cost = z;
	e[tot].next = h[x];
	h[x] = tot;
}

int spfa(int beg){
	memset(cnt , 0 , sizeof(cnt));
	memset(dis , 0x3f , sizeof(dis));
	memset(vis , 0 , sizeof(vis));
	queue<int>q;q.push(beg);vis[beg] = 1;dis[beg] = 0;cnt[beg] = 1;
	int now;
	while(!q.empty()){
		now = q.front();q.pop();vis[now] = 0;
		for(int i = h[now] ; i != (-1) ; i = e[i].next){
			if(dis[e[i].to] > dis[now] + e[i].cost){
				dis[e[i].to] = dis[now] + e[i].cost;
				cnt[e[i].to] = cnt[now] + 1;
				if(cnt[e[i].to] > n)return 2;
				if(!vis[e[i].to])vis[e[i].to] = 1 , q.push(e[i].to);
			}
		}
	}
	return 1;
}

void init(){
	memset(h , -1 , sizeof(h));tot = 0;
	cin>>n>>m;int x , y , z;
	for(int i = 1 ; i <= m ; i++){
		cin>>x>>y>>z;
		add(x , y , z);
		if(z >= 0)add(y , x , z);
	}
	if(spfa(1) == 2)cout<<"YES"<<endl;
	else cout<<"NO"<<endl;	
}

int main(){
	cin>>T;
	while(T--){
		init();	
	}
}

#include<bits/stdc++.h>
#define MAXN 30005
typedef long long ll;
using namespace std;

int T,n,m,h[MAXN],tot,dis[MAXN],vis[MAXN],in[MAXN];

struct node{
	int from,to,cost,next;
}e[MAXN << 1];

queue<int>q;

void add(int x , int y , int z){
	tot++;
	e[tot].from = x;
	e[tot].to = y;
	e[tot].cost = z;
	e[tot].next = h[x];
	h[x] = tot;
}

int spfa(int beg){
	memset(in , 0 , sizeof(in));
	memset(dis , 0x3f , sizeof(dis));
	memset(vis , 0 , sizeof(vis));
	queue<int>q;q.push(beg);vis[beg] = 1;dis[beg] = 0;
	int now;
	while(!q.empty()){
		now = q.front();q.pop();vis[now] = 0;
		for(int i = h[now] ; i != (-1) ; i = e[i].next){
			if(dis[e[i].to] > dis[now] + e[i].cost){
				dis[e[i].to] = dis[now] + e[i].cost;
				in[e[i].to]++;
				if(in[e[i].to] > n)return 2;
				if(!vis[e[i].to])vis[e[i].to] = 1 , q.push(e[i].to);
			}
		}
	}
	return 1;
}

void init(){
	memset(h , -1 , sizeof(h));tot = 0;
	cin>>n>>m;int x , y , z;
	for(int i = 1 ; i <= m ; i++){
		cin>>x>>y>>z;
		add(x , y , z);
		if(z >= 0)add(y , x , z);
	}
	if(spfa(1) == 2)cout<<"YES"<<endl;
	else cout<<"NO"<<endl;	
}

int main(){
	cin>>T;
	while(T--){
		init();	
	}
}

luoguP1257 平面上的最接近点对
O ( n 2 ) O(n^2) O(n2)枚举即可

#include<bits/stdc++.h>
#define MAXN 10005
using namespace std;

int n;
double ans = 99999999;
struct node{
	double x,y;
}t[MAXN];

int main(){
	cin>>n;
	for(int i = 1 ; i <= n ; i++)cin>>t[i].x>>t[i].y;
	for(int i = 1 ; i <= n ; i++){
		for(int j = i + 1 ; j <= n ; j++){
			ans = min(ans , sqrt((t[i].x - t[j].x) * (t[i].x - t[j].x) + (t[i].y - t[j].y) * (t[i].y - t[j].y)));
		}
	}
	printf("%.4f\n" , ans);
}
After__rain
关注
专栏目录
北京东城区初三数学期末考试题及答案.doc
10-12
1. **一元二次方程的根与判别式的关系**：题目中的第1题涉及一元二次方程的根的情况。如果一个一元二次方程有两个相等的实数根，那么判别式Δ=b²-4ac应该等于0。通过比较四个选项，可以分析出哪个方程的判别式满足...
P5199 [USACO19JAN]Mountain View S(区间&排序)
Harris-H的博客
01-05 751
P5199 [USACO19JAN]Mountain View S(区间&排序) 本质是区间问题。 考虑每个三角形在xxx轴上的区间[l,r][l,r][l,r]。 包含关系转换为：一个区间包含另一个区间。 这样的话问题就是有多少个区间不被其他区间包含了。 该问题可以按照左端点从小到大排序，右端点从大到小排序。 同时维护一个rmaxrmaxrmax 变量。 对于当前区间[l,r][l,r][l,r]。 如果r>rmaxr>rmaxr>rmax 显然答案+1+1+1，因为不可能被之前
初三计算机word 操作题,信息技术中考word操作题.doc
weixin_39750598的博客
07-12 2083
1.对c 盘下的Documents and Settings文件创建桌面快捷方式。2. 存放着我平时从网上搜集到的一些文件(存放于处理文件夹中)资料，请帮助我做如下的归类整理。(1)在该文件夹下建立“音乐”、“图片”、“文本”三个文件夹。(2)将该文件夹下的文件，按照类型分别存放到不同的子文件夹中。对备份.doc进行如下处理：1.添加标题“60亿人同时打电话”，字体为隶书一号，对齐方式为居中。2...
中考化学计算机题教案,初三化学计算题专题复习教案.doc
weixin_39950824的博客
07-11 644
初三化学计算题专题复习教案初中化学总复习化学计算一．考点梳理1.有关化学式的计算；2.根据化学方程式的计算；3.有关溶液的计算；二．做题技巧1．认真读题，勾画出有效信息，其中包括：题中所给的“标签”、“图表”等，必须将题中所有你认为有用信息勾画出来；．认真读题，我们要求什么，我们已知条件是什么，我们还需要什么，计算公式是什么？三．经典例题1. (2011 北京.18)已知一种碳原子可用于测定文物的...
2020.5月做题记录
Panda_Hu's blog
06-21 543
之前自己做的做题记录，保存一下吧。
初三计算机课程试题,中考信息技术试题
weixin_42355999的博客
07-05 230
出国留学网中考网为大家提供山西省2016年中考信息技术试题，更多中考化学复习资料请关注我们网站的更新!山西省2016年中考信息技术试题>>>点击下载点击下面图片即可下载山西省2016年中考信息技术试题：2016年中考信息技术试题命题说明1.本试题共20道，为任务类综合应用操作题。重点考查学生利用信息技术解决实际问题的综合应用能力。2.命题依据是《山西省初级中学信息技术课程教学指导...
初三的计算机知识点,初三电脑考试试题
weixin_35601611的博客
06-19 135
初三计算机考试试题(模拟)1、(4分)在D盘根目录下新建如图1所示的文件夹，文件夹名：准考证号+姓名，同时在文件夹中建立一个readme.txt文件，并向该文件中依次输入如图2所示的三行信息(班级、姓名、准考证号)。图1图22、打开“四嬉铜娃.txt”文档，完成以下操作：(1)将提供的文本内容复制到新建的word文档中，以自己的姓名为文件名，保存该文档到第一题建立的文件夹中。(2分)(2)设置标题...
微型计算机题,初三微机考试试题
weixin_42520580的博客
07-02 935
本册教材的特点：为了迎接信息时代的挑战，适应信息化社会的要求，我国高中信息技术课程改革正在轰轰烈烈的开展，新的高中信息技术课程标准也已经出台。在这种情况下，以往的初中信息技术教材已不能适应时代对学生的要求，初中教材改革势在必行，这套教材正是这种改革的一种尝试。它吸取以往教材的特点，遵照《中小学信息技...本册教材的特点：为了迎接信息时代的挑战，适应信息化社会的要求，我国高中信息技术课程改革正在轰轰...
省赛前的做题计划&记录
lahlah的博客
03-21 410
NO EXCUSES
高考生需要考计算机吗,高考时间确定！未来几年比较“热门”的专业，高考生要注意...
weixin_39765588的博客
07-24 332
原标题：高考时间确定！未来几年比较“热门”的专业，高考生要注意愿你七月考出超常成绩，八月被理想学校录取，九月玩得开心不留遗憾，十月和喜欢的人读一所学校，不负韶华。转眼间春节已经进入了尾声，高三学子陆陆续续开学了，但是今年寒假对高三学子来说可能是这是十几年来最不“开心”的寒假，因为距离2021年高考时间已经确定6月7日，不到四个月了，高三学子要为高考开始奋斗。 作为家长和学生除了关心高考之外，高考志...
中考化学计算机题教案,初三化学中考计算题专题复习
weixin_39763293的博客
07-11 411
初三化学中考计算题专题复习一、质量守恒定律1.理解质量守恒定律抓住“五个不变”、“两个一定改变”及“一个可能改变”，即：2.运用质量守恒定律解释实验现象的一般步骤为：(1)说明化学反应的反应物、生成物(2)根据质量守恒定律，应该是参加化学反应的各物质质量总和等于各生成物质量总和；(3)与题目中实验现象相联系，说明原因。3.应用质量守恒定律时应注意：(1)质量守恒定律只能解释化学变化而不能解释物理变...
初三化学必做题汇总.rar
07-09
【初三化学必做题汇总】是一个针对初中三年级学生的化学学习资源压缩包，主要包含了大量化学题目，旨在帮助学生系统地复习和巩固初三阶段所学的化学知识。在准备中考化学部分时，这样的资源是非常宝贵的，它能提供...
第一学期初三化学月考试题1答案.doc
01-21
第一学期初三化学月考试题1答案.doc
初三化学推断题题眼总结.docx
09-20
【初三化学推断题题眼总结】 在化学学习中，推断题是常见的考察形式，它需要学生根据题目给出的线索进行分析，从而确定未知物质的性质或化学反应过程。以下是一些关键知识点，帮助初三学生更好地解答此类题目。 1....
学年初三数学期末考试题及答案.pdf
02-11
1. 数学考试结构：试卷分为选择题和非选择题两部分，选择题共分，非选择题共分，总分为分，考试时间为分钟。 2. 答题规则：选择题需用铅笔涂卡，非选择题需用黑色钢笔或签字笔在指定区域作答。 3. 选择题技巧：每...
Java 代码实现了一个简单的文本编辑器-可运行
10-17
Java 代码实现了一个简单的文本编辑器
MATLAB实现基于Attention-LSTM的多特征分类预测（含完整的程序和代码详解）
10-17
内容概要：本文详细介绍了如何使用MATLAB实现基于Attention机制的LSTM模型进行多特征分类预测。主要内容包括程序设计思路、代码实现、模型构建与训练、模型评估及可视化、以及简单的GUI界面设计。模型可以在多个领域应用，如金融数据分析、医疗诊断等。 适合人群：对深度学习和分类预测感兴趣的科研人员和开发人员，具备一定的MATLAB和深度学习基础。 使用场景及目标：适用于需要处理时间序列数据并进行分类预测的项目。目标是通过Attention-LSTM模型提高分类准确率，同时提供直观的可视化结果和友好的用户界面。 其他说明：文中提供了详细的代码实现和注释，读者可以通过实践加深对模型的理解。此外，还讨论了模型优化和未来的研究方向。
基于Flask和SQLAlchemy 的简易仓库管理系统源码(期末课程设计).zip
10-17
基于Flask和SQLAlchemy 的简易仓库管理系统源码(期末课程设计).zip 1.多数小白下载后，在使用过程，可能会遇到些小问题，若自己解决不了，请及时私信描述你的问题，我会第一时间提供帮助，也可以远程指导 2.项目代码完整可靠，谈不上高分、满分(多数为夸大其词），但难度适中，满足一些毕设、课设要求，且属于易上手的优质项目，项目内基本都有说明文档，按照操作即可，遇到困难也可私信交流 3.适用人群：各大计算机相关专业行业的在校学生、高校老师、公司程序员等下载使用 4.特别是那种爱钻研学习的学霸，强烈推荐此项目，可以二次开发提升自己。如果确定自己是学渣，拿来作毕设、课设直接用也无妨，但自己还是尽可能弄懂项目最好！
民航网上订票系统 JAVA毕业设计 源码+数据库+论文 Vue.js+SpringBoot+MySQL.zip
最新发布
10-17
民航网上订票系统 JAVA毕业设计 源码+数据库+论文 Vue.js+SpringBoot+MySQL 系统启动教程：https://www.bilibili.com/video/BV11ktveuE2d
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值