plwz
plwz

2019 GDUT Winter Training IV ( 图论基础和基础数论 ) 题解

      2019 GDUT Winter Training IV ( 图论基础和基础数论 ) 题解

                                                 A题

题面：

                                     A - Invitation Cards

In the age of television, not many people attend theater performances. Antique Comedians of Malidinesia are aware of this fact. They want to propagate theater and, most of all, Antique Comedies. They have printed invitation cards with all the necessary information and with the programme. A lot of students were hired to distribute these invitations among the people. Each student volunteer has assigned exactly one bus stop and he or she stays there the whole day and gives invitation to people travelling by bus. A special course was taken where students learned how to influence people and what is the difference between influencing and robbery. 

The transport system is very special: all lines are unidirectional and connect exactly two stops. Buses leave the originating stop with passangers each half an hour. After reaching the destination stop they return empty to the originating stop, where they wait until the next full half an hour, e.g. X:00 or X:30, where 'X' denotes the hour. The fee for transport between two stops is given by special tables and is payable on the spot. The lines are planned in such a way, that each round trip (i.e. a journey starting and finishing at the same stop) passes through a Central Checkpoint Stop (CCS) where each passenger has to pass a thorough check including body scan. 

All the ACM student members leave the CCS each morning. Each volunteer is to move to one predetermined stop to invite passengers. There are as many volunteers as stops. At the end of the day, all students travel back to CCS. You are to write a computer program that helps ACM to minimize the amount of money to pay every day for the transport of their employees. 

Input

The input consists of N cases. The first line of the input contains only positive integer N. Then follow the cases. Each case begins with a line containing exactly two integers P and Q, 1 <= P,Q <= 1000000. P is the number of stops including CCS and Q the number of bus lines. Then there are Q lines, each describing one bus line. Each of the lines contains exactly three numbers - the originating stop, the destination stop and the price. The CCS is designated by number 1. Prices are positive integers the sum of which is smaller than 1000000000. You can also assume it is always possible to get from any stop to any other stop.

Output

For each case, print one line containing the minimum amount of money to be paid each day by ACM for the travel costs of its volunteers.

Sample Input

2
2 2
1 2 13
2 1 33
4 6
1 2 10
2 1 60
1 3 20
3 4 10
2 4 5
4 1 50

Sample Output

46
210

题面描述：

            这个题目的大概意思是，所有的ACM会员都要从起点到预定的站点去邀请乘客，然后在一天结束后，所有的ACM会员都会回到起点，题目中的起点默认是第一个站点，这个题目让我们求的是这些ACM会员从起点去到其他站点一来一回最少的花费是多少。（这个题目给的数据从某个站点到另一个站点是单向的）

题目分析：

            我们分为两步，第一步是求从第一个站到达其他站的最短路径，这个过程我们可以用Dijkstra算法或者spfa来算出来。

            第二步，我们是要求从其他所有站点回到第一个站点的最短路径，如果我们枚举全部站点到达第一个站点的最短路径，很显然会超时，因此我们构建原本构建的图的反向图，然后再求第一个站点到达其他站点的最短路径。

            最后对于每个站点，我们把两次求出来的最短路径全部加起来即为答案。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
const int MaxP=1e6+5;
const int MaxQ=1e6+5;
struct Bus
{
	int s,t,price;
};
struct node
{
	int t,price;
};
Bus bus[MaxQ];
node edge[MaxQ];
ll cost[MaxP],costt[MaxP];
priority_queue  q;
int tot,P;
int nextt[MaxP],first[MaxP];
bool operator < (node a,node b)
{
	return a.price>b.price;
}
void addedge(int a,int b,int price)
{
	edge[++tot].t=b;
	edge[tot].price=price;
	nextt[tot]=first[a];
	first[a]=tot;
}
void Dijkstra()
{
	for (reg int i=1;i<=P;i++) cost[i]=INF; 
	node temp;
	temp.t=1;temp.price=0;
	q.push(temp);cost[1]=0;
	while (!q.empty())
	{
		temp=q.top();q.pop();
		for (reg int i=first[temp.t];i!=-1;i=nextt[i])
		if (cost[temp.t]+edge[i].price

 

                                                 B题

题面：

                                           B - ROADS

N cities named with numbers 1 ... N are connected with one-way roads. Each road has two parameters associated with it : the road length and the toll that needs to be paid for the road (expressed in the number of coins). 
Bob and Alice used to live in the city 1. After noticing that Alice was cheating in the card game they liked to play, Bob broke up with her and decided to move away - to the city N. He wants to get there as quickly as possible, but he is short on cash. 

We want to help Bob to find the shortest path from the city 1 to the city N that he can afford with the amount of money he has. 

Input

The first line of the input contains the integer K, 0 <= K <= 10000, maximum number of coins that Bob can spend on his way. 
The second line contains the integer N, 2 <= N <= 100, the total number of cities. 

The third line contains the integer R, 1 <= R <= 10000, the total number of roads. 

Each of the following R lines describes one road by specifying integers S, D, L and T separated by single blank characters : 

  • S is the source city, 1 <= S <= N 
  • D is the destination city, 1 <= D <= N 
  • L is the road length, 1 <= L <= 100 
  • T is the toll (expressed in the number of coins), 0 <= T <=100


Notice that different roads may have the same source and destination cities.

Output

The first and the only line of the output should contain the total length of the shortest path from the city 1 to the city N whose total toll is less than or equal K coins. 
If such path does not exist, only number -1 should be written to the output. 

Sample Input

5
6
7
1 2 2 3
2 4 3 3
3 4 2 4
1 3 4 1
4 6 2 1
3 5 2 0
5 4 3 2

Sample Output

11

题面描述：

             这个题目求的是从第一个城市到达第n个城市的最短路径，并且这个最短路径的总花费不能超过K。

题目分析：

            这个题目的求解就是要在Dijkstra算法求解最短路径的时候加上判别第一个城市到达当前城市的总花费是否超过K，然后最后输出满足条件的从第一个城市到达第n个城市的最短路径即可。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
const int MaxN=105;
const int MaxR=1e5+5;
const int MaxK=1e5+5;
struct node
{
	int t,len,toll;
};
int N,K,tot;
int nextt[MaxR],first[MaxN];
node edge[MaxR];
priority_queue  q;
bool operator < (node a,node b)
{
	return a.len>b.len;
}
void addedge(int a,int b,int len,int toll)
{
	edge[++tot].t=b;
	edge[tot].len=len;
	edge[tot].toll=toll;
	nextt[tot]=first[a];
	first[a]=tot;
}
int Dijkstra()
{
	node temp;
	temp.t=1;temp.len=0;temp.toll=0;
	q.push(temp);
	while (!q.empty())
	{
		temp=q.top();q.pop();
		if (temp.t==N) return temp.len;
		for (reg int i=first[temp.t];i!=-1;i=nextt[i])
		if (temp.toll+edge[i].toll<=K)
		{
			node tt;
			tt.t=edge[i].t;tt.len=temp.len+edge[i].len;tt.toll=temp.toll+edge[i].toll;
			q.push(tt);
		}
	}
}
int main()
{
	int R;
	tot=0;
	memset(first,-1,sizeof(first));
	scanf("%d%d%d",&K,&N,&R);
	for (reg int i=1;i<=R;i++)
	{
		int S,D,L,T;
		scanf("%d%d%d%d",&S,&D,&L,&T);
		addedge(S,D,L,T); 
	}
	printf("%d\n",Dijkstra());
	return 0;
}

 

                                                 C题

题面：

                                       C - Popular Cows

Every cow's dream is to become the most popular cow in the herd. In a herd of N (1 <= N <= 10,000) cows, you are given up to M (1 <= M <= 50,000) ordered pairs of the form (A, B) that tell you that cow A thinks that cow B is popular. Since popularity is transitive, if A thinks B is popular and B thinks C is popular, then A will also think that C is 
popular, even if this is not explicitly specified by an ordered pair in the input. Your task is to compute the number of cows that are considered popular by every other cow. 

Input

* Line 1: Two space-separated integers, N and M 

* Lines 2..1+M: Two space-separated numbers A and B, meaning that A thinks B is popular. 

Output

* Line 1: A single integer that is the number of cows who are considered popular by every other cow. 

Sample Input

3 3
1 2
2 1
2 3

Sample Output

1

Hint

Cow 3 is the only cow of high popularity. 

题面描述：

            这个题目讲述的是，如果奶牛A认为奶牛B很受关注，然后奶牛B也认为奶牛C很受关注，因此便得出奶牛A认为奶牛C很受关注（即奶牛之间的受关注是具有传递性的），然后就是要求出n头奶牛当中有多少头奶牛被其他n-1头奶牛认为很受关注。

题目分析：

             这个题目我们很容易想到，如果两头奶牛之间互相认为对方很受关注，那么我们就可以把这两头奶牛看成是一个整体，其实m头奶牛也一样，因此我们就要把这n头奶牛当中的强连通分量进行缩点（这里可以用Tarjan算法或者Kosaraju算法），然后再判断经过缩点后的每个点的出度是否为0，如果出度为0的点我们记录一下，出度为0的点的个数如果为1的话，就证明存在一个点当中的所有奶牛都被其他奶牛认为很受欢迎，我们把这个点里面的奶牛数计算出来即可（出度为0的点的个数不为1的话，就证明不存在一头奶牛被其他奶牛认为很受欢迎，这是因为这些出度为0的点之间并没有存在一方认为另一方很受欢迎的情况，所以不满足题目条件）。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
const int MaxN=1e4+5;
const int MaxM=5e4+5;
int N,tot,tt,ans,timee;
int dfn[MaxN],cnt[MaxN],num[MaxN],low[MaxN],edge[MaxM],nextt[MaxM],first[MaxN];
bool visit[MaxN];
stack  s;
void addedge(int a,int b)
{
	edge[++tot]=b;
	nextt[tot]=first[a];
	first[a]=tot;
}
void dfs(int cow)
{
	timee++;
	dfn[cow]=low[cow]=timee;
	s.push(cow);
	visit[cow]=1;
	for (reg int i=first[cow];i!=-1;i=nextt[i])
	{
		if (!visit[edge[i]])
		{
			dfs(edge[i]);
			if (low[edge[i]]

 

                                                 D题

题面：

                                    D - Redundant Paths

In order to get from one of the F (1 <= F <= 5,000) grazing fields (which are numbered 1..F) to another field, Bessie and the rest of the herd are forced to cross near the Tree of Rotten Apples. The cows are now tired of often being forced to take a particular path and want to build some new paths so that they will always have a choice of at least two separate routes between any pair of fields. They currently have at least one route between each pair of fields and want to have at least two. Of course, they can only travel on Official Paths when they move from one field to another. 

Given a descri_ption of the current set of R (F-1 <= R <= 10,000) paths that each connect exactly two different fields, determine the minimum number of new paths (each of which connects exactly two fields) that must be built so that there are at least two separate routes between any pair of fields. Routes are considered separate if they use none of the same paths, even if they visit the same intermediate field along the way. 

There might already be more than one paths between the same pair of fields, and you may also build a new path that connects the same fields as some other path.

Input

Line 1: Two space-separated integers: F and R 

Lines 2..R+1: Each line contains two space-separated integers which are the fields at the endpoints of some path.

Output

Line 1: A single integer that is the number of new paths that must be built.

Sample Input

7 7
1 2
2 3
3 4
2 5
4 5
5 6
5 7

Sample Output

2

Hint

Explanation of the sample: 

One visualization of the paths is: 

1   2   3
   +---+---+  
       |   |
       |   |
 6 +---+---+ 4
      / 5
     / 
    / 
 7 +

Building new paths from 1 to 6 and from 4 to 7 satisfies the conditions. 

1   2   3
   +---+---+  
   :   |   |
   :   |   |
 6 +---+---+ 4
      / 5  :
     /     :
    /      :
 7 + - - - -

Check some of the routes: 
1 – 2: 1 –> 2 and 1 –> 6 –> 5 –> 2 
1 – 4: 1 –> 2 –> 3 –> 4 and 1 –> 6 –> 5 –> 4 
3 – 7: 3 –> 4 –> 7 and 3 –> 2 –> 5 –> 7 
Every pair of fields is, in fact, connected by two routes. 

It's possible that adding some other path will also solve the problem (like one from 6 to 7). Adding two paths, however, is the minimum.

题面描述：

            这个题目讲的是，一些奶牛希望F个放牧场当中任意两个放牧场之间存在两条不同的路径，然后输入的R条路径当中保证F个放牧场之间的任意两个放牧场存在至少一条路径，问我们最少建设多少条路径来保证F个放牧场当中任意两个放牧场存在至少两条路径。

题目分析：

            我们知道在这些路径的强连通分量中的任意两个点必定存在两条路径，而我们需要将这些强连通分量进行缩点，排除在我们的考虑范围内，由于将所有的强连通分量进行缩点后，我们重新得到的图类似于一棵树的结构，然后我们只要将这个图的所有度为1的点连起来即可，由于题目保证了任意两个放牧场之间至少存在一条路径，所以不存在度为0的点。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
const int MaxF=5005;
const int MaxR=1e4+5;
int F,tot,timee,cnt;
int num[MaxF],dfn[MaxF],low[MaxF],first[MaxF],degree[MaxF];
int edge[MaxR*2],nextt[MaxR*2];
bool visit[MaxR*2];
stack  s;
void addedge(int a,int b)
{
	edge[tot]=b;
	nextt[tot]=first[a];
	first[a]=tot++;
}
void dfs(int field)
{
	dfn[field]=low[field]=++timee;
	s.push(field);
	for (reg int i=first[field];i!=-1;i=nextt[i])
	{
		if (!visit[i])
		{
			visit[i]=visit[i^1]=1;
			if (!dfn[edge[i]])
			{
				dfs(edge[i]);
				low[field]=min(low[field],low[edge[i]]);
				continue;
			}
			low[field]=min(low[field],dfn[edge[i]]);
		}
	}
	if (low[field]==dfn[field])
	{
		int temp;
		cnt++;
		do
		{
			temp=s.top();
			num[s.top()]=cnt;
			s.pop();
		} while (temp!=field);
	}
}
void Tarjan()
{
	memset(dfn,0,sizeof(dfn));
	memset(low,0,sizeof(low));
	memset(visit,0,sizeof(visit));
	for (reg int i=1;i<=F;i++)
	if (!dfn[i]) dfs(i);
}
int main()
{
	int R;
	while (~scanf("%d%d",&F,&R))
	{
		memset(first,-1,sizeof(first));
		memset(degree,0,sizeof(degree));
		cnt=tot=timee=0;
		for (reg int i=1;i<=R;i++)
		{
			int a,b;
			scanf("%d%d",&a,&b);
			addedge(a,b);
			addedge(b,a);
		}
		Tarjan();
		memset(visit,0,sizeof(visit));
		for (reg int i=1;i<=F;i++)
		{
			for (reg int j=first[i];j!=-1;j=nextt[j])
			if (num[edge[j]]!=num[i] && !visit[j])
			{
				visit[j]=visit[j^1]=1;
				degree[num[i]]++;
				degree[num[edge[j]]]++;
			}
		}
		int ans=0;
		for (reg int i=1;i<=cnt;i++)
		if (degree[i]==1) ans++;
		printf("%d\n",(ans+1)/2); 
	}
	return 0;
}

 

                                                 E题

题面：

                              E - Til the Cows Come Home

Bessie is out in the field and wants to get back to the barn to get as much sleep as possible before Farmer John wakes her for the morning milking. Bessie needs her beauty sleep, so she wants to get back as quickly as possible. 

Farmer John's field has N (2 <= N <= 1000) landmarks in it, uniquely numbered 1..N. Landmark 1 is the barn; the apple tree grove in which Bessie stands all day is landmark N. Cows travel in the field using T (1 <= T <= 2000) bidirectional cow-trails of various lengths between the landmarks. Bessie is not confident of her navigation ability, so she always stays on a trail from its start to its end once she starts it. 

Given the trails between the landmarks, determine the minimum distance Bessie must walk to get back to the barn. It is guaranteed that some such route exists.

Input

* Line 1: Two integers: T and N 

* Lines 2..T+1: Each line describes a trail as three space-separated integers. The first two integers are the landmarks between which the trail travels. The third integer is the length of the trail, range 1..100.

Output

* Line 1: A single integer, the minimum distance that Bessie must travel to get from landmark N to landmark 1.

Sample Input

5 5
1 2 20
2 3 30
3 4 20
4 5 20
1 5 100

Sample Output

90

Hint

INPUT DETAILS: 

There are five landmarks. 

OUTPUT DETAILS: 

Bessie can get home by following trails 4, 3, 2, and 1.

题面描述：

            这个题目输入n个地标，T条双向的路径，然后让你求出从第一个地标到达第n个地标的最短路径。

题目分析：

            这个题目就是经典的单源最短路径问题，直接用Dijkstra算法求出第一个地表求出第n个地表的最短路径。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
const int MaxN=1005;
const int MaxT=2005;
struct node
{
	int t,len;
};
int tot;
int nextt[MaxT*2],first[MaxN],dist[MaxN];
node edge[MaxT*2];
bool operator < (node a,node b)
{
	return a.len q;
	memset(dist,INF,sizeof(dist));
	node temp;
	temp.t=1;temp.len=0;
	q.push(temp);
	dist[1]=0;
	while (!q.empty())
	{
		node temp=q.top();
		q.pop();
		int t=temp.t,len=temp.len;
		for (reg int i=first[t];i!=-1;i=nextt[i])
		if (len+edge[i].len

 

                                                 F题

题面：

                                       F - Roadblocks

Bessie has moved to a small farm and sometimes enjoys returning to visit one of her best friends. She does not want to get to her old home too quickly, because she likes the scenery along the way. She has decided to take the second-shortest rather than the shortest path. She knows there must be some second-shortest path.

The countryside consists of R (1 ≤ R ≤ 100,000) bidirectional roads, each linking two of the N (1 ≤ N ≤ 5000) intersections, conveniently numbered 1..N. Bessie starts at intersection 1, and her friend (the destination) is at intersection N.

The second-shortest path may share roads with any of the shortest paths, and it may backtrack i.e., use the same road or intersection more than once. The second-shortest path is the shortest path whose length is longer than the shortest path(s) (i.e., if two or more shortest paths exist, the second-shortest path is the one whose length is longer than those but no longer than any other path).

Input

Line 1: Two space-separated integers: N and R 
Lines 2.. R+1: Each line contains three space-separated integers: A, B, and D that describe a road that connects intersections A and B and has length D (1 ≤ D ≤ 5000)

Output

Line 1: The length of the second shortest path between node 1 and node N

Sample Input

4 4
1 2 100
2 4 200
2 3 250
3 4 100

Sample Output

450

Hint

Two routes: 1 -> 2 -> 4 (length 100+200=300) and 1 -> 2 -> 3 -> 4 (length 100+250+100=450)

题面描述：

            这个题目求的是从第一个路口到达第n个路口的次短路径（即仅比最短路长的路径）。

题目分析：

            这个题目可以用Dijkstra算法在记录从第一个路口到达当前路口的最短路径的时候记录次短路径即可，这是因为从第一个路口到达当前路口的次短路径只能从前面状态的最短路径加上次短路径或者从前面状态的次短路径加上最短路径，所以我们可以在更新最短路径的时候顺便更新次短路径，最后输出我们记录的从第一个路口到达第n个路口的次短路径即可。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
const int MaxN=5005;
const int MaxR=1e5+5;
struct node
{
	int t,dist;
};
int N,tot;
node edge[MaxR*2];
int first[MaxN],dist[2][MaxN];
int nextt[MaxR*2];
bool visit[2][MaxN];
bool operator < (node a,node b)
{
	return a.dist

 

                                                 G题

题面：

                                           G - 有点难的

Petya loves volleyball very much. One day he was running late for a volleyball match. Petya hasn't bought his own car yet, that's why he had to take a taxi. The city has n junctions, some of which are connected by two-way roads. The length of each road is defined by some positive integer number of meters; the roads can have different lengths.

Initially each junction has exactly one taxi standing there. The taxi driver from the i-th junction agrees to drive Petya (perhaps through several intermediate junctions) to some other junction if the travel distance is not more than ti meters. Also, the cost of the ride doesn't depend on the distance and is equal to cibourles. Taxis can't stop in the middle of a road. Each taxi can be used no more than once. Petya can catch taxi only in the junction, where it stands initially.

At the moment Petya is located on the junction x and the volleyball stadium is on the junction y. Determine the minimum amount of money Petya will need to drive to the stadium.

Input

The first line contains two integers n and m (1 ≤ n ≤ 1000, 0 ≤ m ≤ 1000). They are the number of junctions and roads in the city correspondingly. The junctions are numbered from 1 to n, inclusive. The next line contains two integers x and y (1 ≤ x, y ≤ n). They are the numbers of the initial and final junctions correspondingly. Next m lines contain the roads' description. Each road is described by a group of three integers ui, vi, wi (1 ≤ ui, vi ≤ n, 1 ≤ wi ≤ 109) — they are the numbers of the junctions connected by the road and the length of the road, correspondingly. The next n lines contain n pairs of integers ti and ci (1 ≤ ti, ci ≤ 109), which describe the taxi driver that waits at the i-th junction — the maximum distance he can drive and the drive's cost. The road can't connect the junction with itself, but between a pair of junctions there can be more than one road. All consecutive numbers in each line are separated by exactly one space character.

Output

If taxis can't drive Petya to the destination point, print "-1" (without the quotes). Otherwise, print the drive's minimum cost.

Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specificator.

Examples

Input

4 4
1 3
1 2 3
1 4 1
2 4 1
2 3 5
2 7
7 2
1 2
7 7

Output

9

Note

An optimal way — ride from the junction 1 to 2 (via junction 4), then from 2 to 3. It costs 7+2=9 bourles.

题面描述：

            这个题目讲述的是，有n个路口，然后有m条路径连接这n个路口其中的两个，Petya现在身处第x个路口，然后排球场在第y个路口，然后每个路口都有一辆出租车，每辆出租车有各自能行驶的最大距离以及花费，然后题目问我们从第x个路口去到第y个路口最少需要花费多少。如果从第x个路口到达不了第y个路口的话就输出-1。

题目分析：

            这个题目需要求两次最短路径，我们第一次先预处理每个路口的出租车在满足行驶距离不超过最大的行驶距离的条件，我们从当前路口不断拓展到新的路口，记录当前路口到达其他路口的最短路径。

            第二次我们从第x个路口求出到达其他路口的最少花费，利用第一次处理出来满足条件的当前路口到达其他路口的方案，最后输出从第x个路口到达第y个路口的最少花费即可，如果不存在的话，输出-1即可。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define bll __int128
#define INF 0x3f3f3f3f3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
typedef pair P;
const int Maxn=1005;
const int Maxm=1005;
struct Edge
{
	int t,next;
	ll len;
};
struct Taxi
{
	ll t,c;
};
int n,tot;
int first[Maxn];
ll cost[Maxn],dist[Maxn][Maxn];
Edge edge[Maxm*2];
Taxi taxi[Maxn];
void addedge(int u,int v,ll w)
{
	edge[++tot].t=v;
	edge[tot].next=first[u];
	edge[tot].len=w;
	first[u]=tot;
}
void Dijkstra(int s)
{
	priority_queue ,greater
 > q;
	dist[s][s]=0;
	q.push(P(s,dist[s][s]));
	while (!q.empty())
	{
		P p=q.top();
		q.pop();
		int v=p.first;
		if (p.second>dist[s][v]) continue;
		for (reg int i=first[v];i!=-1;i=edge[i].next)
		{
			if (dist[s][v]+edge[i].len,greater
 > q;
	fill(cost,cost+Maxn,INF);
	cost[s]=0;
	q.push(P(s,cost[s]));
	while (!q.empty())
	{
		P p=q.top();q.pop();
		int v=p.first;
		if (p.second>cost[v]) continue;
		for (reg int i=1;i<=n;i++)
		{
			if (dist[v][i]<=taxi[v].t && cost[v]+taxi[v].c>n>>m>>x>>y;
	memset(first,-1,sizeof(first));
	tot=0;
	for (reg int i=1;i<=m;i++)
	{
		int u,v;
		ll w;
		cin>>u>>v>>w;
		addedge(u,v,w);
		addedge(v,u,w);
	}
	for (reg int i=1;i<=n;i++)
	{
		for (reg int j=1;j<=n;j++) dist[i][j]=INF;
	}
	for (reg int i=1;i<=n;i++)
	{
		cin>>taxi[i].t>>taxi[i].c;
		Dijkstra(i);
	}
	solve(x);
	if (cost[y]==INF) cout<<"-1"<

 

                                                 H题

题面：

                                             H - 很难

Okabe likes to be able to walk through his city on a path lit by street lamps. That way, he doesn't get beaten up by schoolchildren.

Okabe's city is represented by a 2D grid of cells. Rows are numbered from 1 to nfrom top to bottom, and columns are numbered 1 to m from left to right. Exactly kcells in the city are lit by a street lamp. It's guaranteed that the top-left cell is lit.

Okabe starts his walk from the top-left cell, and wants to reach the bottom-right cell. Of course, Okabe will only walk on lit cells, and he can only move to adjacent cells in the up, down, left, and right directions. However, Okabe can also temporarily light all the cells in any single row or column at a time if he pays 1coin, allowing him to walk through some cells not lit initially.

Note that Okabe can only light a single row or column at a time, and has to pay a coin every time he lights a new row or column. To change the row or column that is temporarily lit, he must stand at a cell that is lit initially. Also, once he removes his temporary light from a row or column, all cells in that row/column not initially lit are now not lit.

Help Okabe find the minimum number of coins he needs to pay to complete his walk!

Input

The first line of input contains three space-separated integers n, m, and k (2 ≤ n, m, k ≤ 104).

Each of the next k lines contains two space-separated integers ri and ci (1 ≤ ri ≤ n, 1 ≤ ci ≤ m) — the row and the column of the i-th lit cell.

It is guaranteed that all k lit cells are distinct. It is guaranteed that the top-left cell is lit.

Output

Print the minimum number of coins Okabe needs to pay to complete his walk, or -1 if it's not possible.

Examples

Input

4 4 5
1 1
2 1
2 3
3 3
4 3

Output

2

Input

5 5 4
1 1
2 1
3 1
3 2

Output

-1

Input

2 2 4
1 1
1 2
2 1
2 2

Output

0

Input

5 5 4
1 1
2 2
3 3
4 4

Output

3

Note

In the first sample test, Okabe can take the path , paying only when moving to (2, 3) and (4, 4).

In the fourth sample, Okabe can take the path  , paying when moving to (1, 2), (3, 4), and (5, 4).

题面描述：

            题目输入一个由n*m个网格组成的一座城市，然后有k个被灯光照亮的网格，Okabe从(1,1)出发，每次可以向上，向下，向左或者向右走，但是必须保证每次到达的网格都是有灯光照亮的，Okabe可以使用一次魔法使任意一行或者任意一列都照亮，但是他如果要再次使用魔法的话，就要把先前使用的魔法撤销掉，每次使用魔法的话都要花费一个金币，然后题目问我们最少需要多少金币可以从(1,1)走到(n,m)，如果走不到的话，就输出-1。

题目分析：

            这个题目由于原本照亮的点的个数比较多，如果我们每个点去判断和其他点的关系的话，那么这样的做法显然是时间复杂度比较高的，会出现超时的。

            首先我们知道如果两个被照亮的点相邻的话，那么我们不用花费任何金币就可以当中的一个点走到另外一个点。

            如果两个原本照亮的点在同一行或者同一列的话（不包含相邻的情况），那么我们知道只需要把相同的行照亮或者相同的列照亮就行，花费一个金币。

            如果两个原本照亮的点在相邻的行或者在相邻的列的话（不包含以上情况），那么我们从其中一个点走到另一个点只需要把另一个点所在的行或者所在的列照亮即可，花费一个金币。

            如果两个原本照亮的点隔着一行或者隔着一列的话（不包含以上情况），那么我们从其中一个点走到另一个点只需中间隔着的一行或者中间隔着的一列照亮即可，花费一个金币。

            我们可以看到除了相邻的情况之外，其他情况均与第几行和第几列有关，与这个点具体在第几行第几列关系并不是很大。

            因此我们可以在每一行和每一列引入两个虚点，一个是入点，每个入点连接着记录的这一行的所有点或者是记录的这一列的所有点，权值为0，一个是出点，每个出点被记录的这一行的所有点或者是记录的这一列的所有点所连接着，权值一样是0。那么每一行的具体关系就可以由这些虚点去表示，相邻的情况要必须先预处理，然后再处理好这些虚点的关系。

            在运用Dijkstra算法计算最少花费之前，要先把从(1,1)拓展得出来的所有原本照亮的点压入队列，Dijkstra算法结束后也一样，把能够拓展到(n,m)的花费都算出来，取最小值输出即可。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define bll __int128
#define INF 0x3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
const int Maxn=1e4+5;
const int Maxm=1e4+5;
const int Maxk=1e4+5;
const int dx[4]={-1,1,0,0};
const int dy[4]={0,0,-1,1}; 
typedef pair p;
struct Cell
{
	int x,y;
};
struct Edge
{
	int t,val,next;
};
Edge edge[15000005];
Cell cell[Maxk];
map  s[Maxn];
int tot,kk,k;
int first[Maxk+(Maxn<<1)+(Maxm<<1)];
int dist[Maxk+(Maxn<<1)+(Maxm<<1)];
void addedge(int a,int b,int val)
{
	edge[++tot].t=b;
	edge[tot].val=val;
	edge[tot].next=first[a];
	first[a]=tot;
}
void Dijkstra()
{
	memset(dist,INF,sizeof(dist));
	priority_queue ,greater
 > q;
	int t=-1;
	for (reg int i=1;i<=kk;i++)
	{
		if (cell[i].x==1 && cell[i].y==1)
		{
			t=i;
			dist[i]=0;
			q.push(p(0,i));
			break;
		}
	}
	if (t==-1)
	{
		for (reg int i=1;i<=kk;i++)
		{
			if (abs(cell[i].x-1)<=1 || abs(cell[i].y-1)<=1)
			{
				dist[i]=1;
				q.push(p(1,i));
			}
		}
	}
	while (!q.empty())
	{
		p temp=q.top();
		q.pop();
		if (dist[temp.second]0)
				{
					addedge(s[xx][yy],i,0);
					addedge(i,s[xx][yy],0);
				}
			}
		}
		kk=k;
		k+=2*n+2*m;
		for (reg int i=1;i<=kk;i++)
		{
			addedge(i,cell[i].x+kk,0);
			addedge(cell[i].x+kk+n,i,0);
			addedge(i,cell[i].y+2*n+kk,0);
			addedge(cell[i].y+2*n+m+kk,i,0);
		}
		for (reg int i=1;i<=n;i++)
		{
			for (reg int j=-2;j<=2;j++)
			{
				int temp=i+j;
				if (temp<1 || temp>n) continue;
				addedge(i+kk,temp+kk+n,1);
				addedge(temp+kk,i+kk+n,1);
			}
		}
		for (reg int i=1;i<=m;i++)
		{
			for (reg int j=-2;j<=2;j++)
			{
				int temp=i+j;
				if (temp<1 || temp>m) continue;
				addedge(i+kk+2*n,temp+kk+2*n+m,1);
				addedge(temp+kk+2*n,i+kk+2*n+m,1);
			}
		}
		Dijkstra();
		int ans=INF;
		for (reg int i=1;i<=kk;i++)
		{
			if (cell[i].x==n && cell[i].y==m)
			{
				ans=min(ans,dist[i]);
				continue;
			}
			if (abs(cell[i].x-n)<=1 || abs(cell[i].y-m)<=1) ans=min(ans,dist[i]+1);
		}
		printf("%d\n",ans==INF?-1:ans);
	}
	return 0;
}

 

                                                 I题

题面：

                                         I - 畅通工程

某省调查城镇交通状况，得到现有城镇道路统计表，表中列出了每条道路直接连通的城镇。省政府“畅通工程”的目标是使全省任何两个城镇间都可以实现交通（但不一定有直接的道路相连，只要互相间接通过道路可达即可）。问最少还需要建设多少条道路？ 

Input

测试输入包含若干测试用例。每个测试用例的第1行给出两个正整数，分别是城镇数目N ( < 1000 )和道路数目M；随后的M行对应M条道路，每行给出一对正整数，分别是该条道路直接连通的两个城镇的编号。为简单起见，城镇从1到N编号。 
注意:两个城市之间可以有多条道路相通,也就是说 
3 3 
1 2 
1 2 
2 1 
这种输入也是合法的 
当N为0时，输入结束，该用例不被处理。 

Output

对每个测试用例，在1行里输出最少还需要建设的道路数目。 

Sample Input

4 2
1 3
4 3
3 3
1 2
1 3
2 3
5 2
1 2
3 5
999 0
0

Sample Output

1
0
2
998
 

Hint

Huge input, scanf is recommended. 

题面描述：

            这个题目讲述的是，输入m条路径，问我们最少还需要修多少条路径去满足n个城镇相互之间至少存在一条路径。

题目分析：

            这个题目只要用并查集把相连的城镇构成一个集合，然后再去计算有多少个集合，根据贪心策略，我们最少可以用集合数减一的路径去把这些集合连接起来即可满足题目条件。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3fffffff
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
const int Maxn=1005;
int father[Maxn];
int find(int x)
{
	return x==father[x]?x:father[x]=find(father[x]);
}
void merge(int a,int b)
{
	int ta=find(a);
	int tb=find(b);
	if (ta!=tb) father[ta]=tb;
}
bool ok(int a,int b)
{
	return find(a)==find(b);
}
int main()
{
	int n,m;
	while (scanf("%d%d",&n,&m),n!=0)
	{
		int ans=n-1;
		for (reg int i=1;i<=n;i++) father[i]=i;
		for (reg int i=1;i<=m;i++)
		{
			int l,r;
			scanf("%d%d",&l,&r);
			if (ok(l,r)) continue;
			merge(l,r);ans--;
		}
		printf("%d\n",ans);
	}
	return 0;
}

 

                                                 J题

题面：

                                      J - Legal or Not

ACM-DIY is a large QQ group where many excellent acmers get together. It is so harmonious that just like a big family. Every day,many "holy cows" like HH, hh, AC, ZT, lcc, BF, Qinz and so on chat on-line to exchange their ideas. When someone has questions, many warm-hearted cows like Lost will come to help. Then the one being helped will call Lost "master", and Lost will have a nice "prentice". By and by, there are many pairs of "master and prentice". But then problem occurs: there are too many masters and too many prentices, how can we know whether it is legal or not?

We all know a master can have many prentices and a prentice may have a lot of masters too, it's legal. Nevertheless，some cows are not so honest, they hold illegal relationship. Take HH and 3xian for instant, HH is 3xian's master and, at the same time, 3xian is HH's master,which is quite illegal! To avoid this,please help us to judge whether their relationship is legal or not. 

Please note that the "master and prentice" relation is transitive. It means that if A is B's master ans B is C's master, then A is C's master.

Input

The input consists of several test cases. For each case, the first line contains two integers, N (members to be tested) and M (relationships to be tested)(2 <= N, M <= 100). Then M lines follow, each contains a pair of (x, y) which means x is y's master and y is x's prentice. The input is terminated by N = 0. 
TO MAKE IT SIMPLE, we give every one a number (0, 1, 2,..., N-1). We use their numbers instead of their names.

Output

For each test case, print in one line the judgement of the messy relationship. 
If it is legal, output "YES", otherwise "NO".

Sample Input

3 2
0 1
1 2
2 2
0 1
1 0
0 0

Sample Output

YES
NO

题面描述：

            题目输入奶牛的总数n，以及n头奶牛当中存在的m种关系，接下来的m行输入代表第一头奶牛教导第二头奶牛，然后问我们这m行输入是否合法。

题目分析：

            这个题目我们画图可以知道，我们将这m行输入的第一头奶牛连接第二头奶牛的话，那么我们发现只有这个图存在环的情况下才不合法，因此我们可以用拓扑排序来判断这个图是否存在环，有环就证明不合法，否则即为合法。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3fffffff
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
const int Maxn=105;
const int Maxm=105;
int n,m,tot,ans;
int edge[Maxm],nextt[Maxm],first[Maxn],cnt[Maxn];
void addedge(int a,int b)
{
	edge[++tot]=b;
	nextt[tot]=first[a];
	first[a]=tot;
	cnt[b]++;
}
void topsort()
{
	stack  q;
	for (reg int i=0;i

 

                                                 K题

题面：

                                       K - Exploration

Miceren likes exploration and he found a huge labyrinth underground! 

This labyrinth has N caves and some tunnels connecting some pairs of caves. 

There are two types of tunnel, one type of them can be passed in only one direction and the other can be passed in two directions. Tunnels will collapse immediately after Miceren passing them. 

Now, Miceren wants to choose a cave as his start point and visit at least one other cave, finally get back to start point. 

As his friend, you must help him to determine whether a start point satisfing his request exists.

Input

The first line contains a single integer T, indicating the number of test cases. 

Each test case begins with three integers N, M1, M2, indicating the number of caves, the number of undirectional tunnels, the number of directional tunnels. 

The next M1 lines contain the details of the undirectional tunnels. Each line contains two integers u, v meaning that there is a undirectional tunnel between u, v. (u ≠ v) 

The next M2 lines contain the details of the directional tunnels. Each line contains integers u, v meaning that there is a directional tunnel from u to v. (u ≠ v) 

T is about 100. 

1 ≤ N,M1,M2 ≤ 1000000. 

There may be some tunnels connect the same pair of caves. 

The ratio of test cases with N > 1000 is less than 5%.

Output

For each test queries, print the answer. If Miceren can do that, output "YES", otherwise "NO".

Sample Input

2
5 2 1
1 2
1 2
4 5
4 2 2
1 2
2 3
4 3
4 1

Sample Output

YES
NO

 

Hint

If you need a larger stack size,
please use #pragma comment(linker, "/STACK:102400000,102400000") and submit your solution using C++.

题面描述：

            这个题目讲述的是，有n个洞穴，然后又m1条双向隧道连接着n个洞穴当中的任意两个洞穴，m2条单向隧道连接着n个洞穴当中的任意两个洞穴，而且每条隧道仅可走一次。问我们是否可以把某一个洞穴设为起点，然后至少经过其他洞穴一次，最后回到起点。

题目分析：

             这个题目我们画图可以知道，如果存在环的话，那么就可以满足条件，但是由于这个题目存在双向路径，并且这些双向路径只能走一次，所以我们不能直接用拓扑排序去判断是否存在环。

             对于这些双向路径，我们需要用并查集去处理一下，我们对每条双向路径连接着的两个洞穴进行并查集的合并操作，经过这样的操作后，我们会发现每个集合当中的任意两个洞穴是可以相互到达的，因此我们可以对这些集合进行缩点操作，然后所有单向路径连接着的两个点我们用它们在各自的集合进行缩点后的点去表示，经过这样的操作过后，双向路径被我们处理掉了，剩下的只是单向路径，因此我们可以用拓扑排序去判断是否存在环即可。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
#define mod 1000000007
using namespace std;
const int MaxN=1e6+5;
const int MaxM1=1e6+5;
const int MaxM2=1e6+5;
int N,tot,ans;
int father[MaxN],first[MaxN],cnt[MaxN],edge[MaxM1+MaxM2],nextt[MaxM1+MaxM2];
int find(int t)
{
	if (t==father[t]) return t;
	father[t]=find(father[t]);
	return father[t];
}
void merge(int a,int b)
{
	int ta=find(a);
	int tb=find(b);
	if (ta!=tb) father[ta]=tb;
}
bool check(int a,int b)
{
	return find(a)==find(b);
}
void addedge(int a,int b)
{
	edge[++tot]=b;
	nextt[tot]=first[a];
	first[a]=tot;
	cnt[b]++;
}
void topsort()
{
	stack  q;
	for (reg int i=1;i<=N;i++)
	if (cnt[father[i]]==0) q.push(father[i]);
	while (!q.empty())
	{
		ans--;
		int num=q.top();q.pop();
		for (reg int i=first[num];i!=-1;i=nextt[i])
		if (--cnt[edge[i]]==0) q.push(edge[i]);
	}
}
int main()
{
	int T;
	scanf("%d",&T);
	while (T--)
	{
		int M1,M2;
		bool ff=0;
		scanf("%d%d%d",&N,&M1,&M2);
		for (reg int i=1;i<=N;i++) father[i]=i;
		for (reg int i=1;i<=M1;i++)
		{
			int u,v;
			scanf("%d%d",&u,&v);
			if (ff) continue;
			if (check(u,v))
			{
				ff=1;continue;
			}
			merge(u,v);
		}
		ans=tot=0;
		if (!ff)
		{
			memset(first,-1,sizeof(first));
			memset(cnt,0,sizeof(cnt));
			for (reg int i=1;i<=N;i++)
			{
				father[i]=find(i);
				if (father[i]==i) ans++;
			}
		}
		for (reg int i=1;i<=M2;i++)
		{
			int u,v;
			scanf("%d%d",&u,&v);
			if (ff) continue;
			addedge(father[u],father[v]);
		}
		if (ff)
		{
			printf("YES\n");
			continue;
		}
		topsort();
		if (ans>0) printf("YES\n");else printf("NO\n");
	}
	return 0;
}

 

                                                 L题

题面：

                                            L - 最短路

有一天雪菜和东马一起组队写代码，在连续WA了233次后，东马忍不住站起来大发雷霆，对雪菜说，

 

明明是我先写的，A题也好，调试也好，可是为什么会这样呢，你为什么WA的这么熟练啊！连这种简单题怎么都不会做？

 

我跟你讲，我可是身经百战了，哪个类型的题我没见过？你知道集训队的CerberuX菊苣吧，就是那个河老师，比你不知道高到哪里去啦，我和他谈笑风生啊！

 

监考老师正巧就是CerberuX老师，他听到了东马的声音注意到了他们，准备走过去提醒他们比赛时不要站起来大声讲话。可是为了避免走动时影响其他同学，他准备找一条最短的路径过去。

 

由于机房非常非常大，而且机器的布局也不规律，所以不同机位之间不一定有通路可以直接走过去，CerberuX一时半会找不出这样的一条路线，你能帮助他找到这条路并计算出需要多长时间才能走过去吗？

Input

输入包括多组数据。

 

每组数据第一行是两个整数N、M（N<=100，M<= 10000），

 

N表示集训队机房内电脑数量，标号为1的是CerberuX的位置，标号为N的是东马和雪菜的位置，M则表示机房内有多少条路。

 

N = M = 0表示输入结束。

 

接下来M行，每行包括3个整数A，B，C（1 <= A,B <= N,1 <= C <= 1000）,表示在机位A与机位B之间有一条路，CerberuX需要C分钟的时间走过这条路。

Output

对于每组输入，输出一行，表示CerberuX从1号位置走到东马和雪菜位置的最短时间。如果CerberuX不能从1号位置走到东马和雪菜的位置，输出-10086。

Sample Input

2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0

Sample Output

3
2

Hint

CerberuX!

 

题面描述：

            这个题目讲述的是，输入n个电脑位置，然后又m条路径，每条路径有对应的时间，问我们从第一个电脑的位置走到第n个电脑的位置的最短时间。

题目分析：

            这个题目就直接用Dijkstra算法来求从第一个电脑位置到达第n个电脑位置的最短时间即可。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
const int Maxn=105;
const int Maxm=10005;
struct node
{
	int num,dist;
	
};
priority_queue  q;
int dist[Maxn],sign[Maxn],mapp[Maxn][Maxn];
bool operator < (node a,node b)
{
	if (a.dist!=b.dist) return a.dist>b.dist;
	return a.num>b.num;
}
int main()
{
	int n,m;
	while (scanf("%d%d",&n,&m),n!=0 || m!=0)
	{
		memset(mapp,INF,sizeof(mapp));
		memset(sign,0,sizeof(sign));
		memset(dist,INF,sizeof(dist));
		for (reg int i=1;i<=m;i++)
		{
			int A,B,C;
			node temp;
			scanf("%d%d%d",&A,&B,&C);
			mapp[A][B]=mapp[B][A]=C;
		}
		while (!q.empty()) q.pop();
		dist[1]=0;sign[1]=1;
		node temp;
		temp.num=1;temp.dist=0;
		q.push(temp);
		while (!q.empty())
		{
			for (reg int i=2;i<=n;i++)
			if (!sign[i] && q.top().dist+mapp[q.top().num][i]

 

                                                 M题

题面：

                                        M - 畅通工程续

某省自从实行了很多年的畅通工程计划后，终于修建了很多路。不过路多了也不好，每次要从一个城镇到另一个城镇时，都有许多种道路方案可以选择，而某些方案要比另一些方案行走的距离要短很多。这让行人很困扰。 

现在，已知起点和终点，请你计算出要从起点到终点，最短需要行走多少距离。

Input

本题目包含多组数据，请处理到文件结束。 
每组数据第一行包含两个正整数N和M(0 接下来是M行道路信息。每一行有三个整数A,B,X(0<=A,B 再接下一行有两个整数S,T(0<=S,T

Output

对于每组数据，请在一行里输出最短需要行走的距离。如果不存在从S到T的路线，就输出-1. 

Sample Input

3 3
0 1 1
0 2 3
1 2 1
0 2
3 1
0 1 1
1 2

Sample Output

2
-1

题面描述：

            这个题目讲述的是，输入n个城镇，然后有m条道路，问我们从第s个城镇到第t个城镇的最短路径。

题目分析：

            这个题目就是直接用Dijkstra算法求从第s个城镇到其他城镇的最短路径即可，如果求出到达第t个城镇的最短路径的话，那么就输出-1。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
const int Maxn=205;
const int Maxm=1005;
struct node
{
	int num,dist;
};
struct Edge
{
	int next,val;
};
Edge edge[Maxm];
int tot,dist[Maxn],nextt[Maxm],first[Maxn];
bool operator < (node a,node b)
{
	return a.dist>b.dist;
}
void addedge(int a,int b,int val)
{
	edge[++tot].next=b;
	edge[tot].val=val;
	nextt[tot]=first[a];
	first[a]=tot;
}
int main()
{
	int n,m;
	while (~scanf("%d%d",&n,&m))
	{
		tot=0;
		memset(dist,INF,sizeof(dist));
		memset(first,-1,sizeof(first));
		for (reg int i=1;i<=m;i++)
		{
			int A,B,X;
			scanf("%d%d%d",&A,&B,&X);
			addedge(A,B,X);
			addedge(B,A,X);
		}
		int S,T;
		scanf("%d%d",&S,&T);
		priority_queue  q;
		dist[S]=0;
		node tt;
		tt.num=S;tt.dist=0;
		q.push(tt);
		while (!q.empty())
		{
			node temp=q.top();
			for (reg int i=first[temp.num];i!=-1;i=nextt[i])
			if (temp.dist+edge[i].val

 

                                                 N题

题面：

                                   N - Fedya and Maths

Fedya studies in a gymnasium. Fedya's maths hometask is to calculate the following expression:

(1n + 2n + 3n + 4n) mod 5

for given value of n. Fedya managed to complete the task. Can you? Note that given number n can be extremely large (e.g. it can exceed any integer type of your programming language).

Input

The single line contains a single integer n (0 ≤ n ≤ 10105). The number doesn't contain any leading zeroes.

Output

Print the value of the expression without leading zeros.

Examples

Input

4

Output

4

Input

124356983594583453458888889

Output

0

Note

Operation x mod y means taking remainder after division x by y.

Note to the first sample:

题面描述：

            这个题目输入一个最大为10的10万次方的数n，问我们1的n次方，2的n次方，3的n次方和4的n次方加起来的结果对5取模的结果是多少。

题目分析：

            这个题目有多种做法去做，下面简单分析一下：

方法一：

             由于这个题目输入的n已经超过了所有的整数类型，所以我们只能用字符串去输入这个数n，由于这个n最多也就10万位，所以我们可以用一个循环去枚举n的每一位来求出答案。

             假设我们已经求出了2的n前i-1位对5取模的值，我们记为a^{b}，假设n的第i位数字为c，那么2的n前i位对5取模的值可以表示为a^{10*b+c}=(a^{b})^{10}*a^{c}，a^{b}对5取模后，显然是一个比5小的数，因此我们可以预处理出2的10次方，3的10次方以及4的10次方对5取模后的值，经过这样的预处理后，我们便可快速知道a^{10*b}对5取模后的值，然后c是一个0到9范围内的整数，因此我们也可以快速预处理出a^{c}对5取模后的值，两者再乘起来对5取模，便是2的n前i位对5取模后的值。

             3的n次方对5取模的值和4的n次方对5取模的值的求法与2的类似，从n的第一位枚举到最后一位后，再把1，2的n次方对5取模后的值，3的n次方对5取模后的值以及4的n次方对5取模后的值加起来再对5取模便可得出答案。

方法二（找规律）：

             众所周知，1的n次方为1。

             2的0次方对5取模后为1，2的1次方对5取模后为2，2的2次方对5取模后为4，2的3次方对5取模后为3，2的4次方对5取模为1，......

             我们会发现2的各个次方对5取模后是一个有周期性的数列：1 2 4 3 1 2 4 3......

             3的0次方对5取模后为1，3的1次方对5取模后为3，3的2次方对5取模后为4，3的3次方对5取模后为2，3的4次方对5取模后为1，......

             我们会发现3的各个次方对5取模后是一个有周期性的数列：1 3 4 2 1 3 4 2......

             4的0次方对5取模后为1，4的1次方对5取模后为4，4的2次方对5取模后为1，4的3次方对5取模后为4，......

             我们会发现4的各个次方对5取模后是一个有周期性的数列：1 4 1 4 1 4 1 4......

             所以我们将这几个数列加起来的数列也是一个周期数列：4 0 0 0 4 0 0 0......

             因此n如果可以被4整除的话，那么答案为4，其余情况均为0。

方法三（欧拉定理）：

             由于5是素数，所以1，2，3和4均与5互质，根据欧拉定理，得：a^{\varphi (m)}\equiv 1\: (mod\: m)，欧拉函数\varphi (5)=4，所以当a=1，2，3和4时，我们可以得到4个式子。

             本题关键求的是a^{n}\: mod\: m，因此这里用到欧拉定理的一个扩展，a^{c}\equiv a^{c\: mod\: \varphi (m)}\: mod\: m，先将后面n\: mod\: \varphi (5)求出来，得到的是一个比4小的数，因此我们可以用一个循环或者用快速幂来求出答案。

欧拉定理的证明如下：

https://blog.csdn.net/hzj1054689699/article/details/80693756

代码：

方法一：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
const int Maxn=1e5+5;
char n[Maxn];
int mi[5][15];
int main()
{
	cin>>n;
	mi[1][0]=mi[2][0]=mi[3][0]=mi[4][0]=1;
	for (reg int i=1;i<=10;i++)
	{
		mi[1][i]=(mi[1][i-1]*1)%5;
		mi[2][i]=(mi[2][i-1]*2)%5;
		mi[3][i]=(mi[3][i-1]*3)%5;
		mi[4][i]=(mi[4][i-1]*4)%5;
	}
	int m2=1,m3=1,m4=1;
	for (reg int i=0;i

方法二：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
const int Maxn=1e5+5;
char n[Maxn];
int main()
{
	cin>>n;
	int t=0;
	for (reg int i=0;i

方法三(欧拉定理)：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
const int Maxn=1e5+5;
char n[Maxn];
int ksm(int p,int n)
{
	int ans=1;
	while (n)
	{
		if (n&1) ans=(ans*p)%5;
		p=(p*p)%5;
		n>>=1;
	}
	return ans;
}
int main()
{
	cin>>n;
	int t=0;
	for (reg int i=0;i

 

                                                 O题

题面：

                                        O - k-rounding

For a given positive integer n denote its k-rounding as the minimum positive integer x, such that x ends with k or more zeros in base 10 and is divisible by n.

For example, 4-rounding of 375 is 375·80 = 30000. 30000 is the minimum integer such that it ends with 4 or more zeros and is divisible by 375.

Write a program that will perform the k-rounding of n.

Input

The only line contains two integers n and k (1 ≤ n ≤ 109, 0 ≤ k ≤ 8).

Output

Print the k-rounding of n.

Examples

Input

375 4

Output

30000

Input

10000 1

Output

10000

Input

38101 0

Output

38101

Input

123456789 8

Output

12345678900000000

题面描述：

            这个题目讲述的是，输入两个数n和k，然后让我们求出n的某个倍数最少要有k个后缀0，并且这个数尽可能的小，让我们输出这个数。

题目分析：

            首先我们先把10的k次方算出来，因为题目要求的这个数的因子包含10的k次方以及n，所以只有找到一个数的因子含有这两个数即可，由于题目要求这个数尽可能小，所以我们将10的k次方和n的最小公倍数求出来便是答案。

            注意：由于本题的n最大为10的9次方，k最大为8，因此我们需要用long long类型的变量来记录答案。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
ll gcd(ll n,ll m)
{
	return n%m?gcd(m,n%m):m;
}
int main()
{
	ll n,num=1;
	int k;
	scanf("%lld%d",&n,&k);
	for (reg int i=1;i<=k;i++) num=num*10;
	ll temp=gcd(n,num);
	printf("%lld\n",n/temp*num);
	return 0;
}

 

                                                 P题

题面：

                                  P - Beautiful Numbers

Vitaly is a very weird man. He's got two favorite digits a and b. Vitaly calls a positive integer good, if the decimal representation of this integer only contains digits a and b. Vitaly calls a good number excellent, if the sum of its digits is a good number.

For example, let's say that Vitaly's favourite digits are 1 and 3, then number 12isn't good and numbers 13 or 311 are. Also, number 111 is excellent and number 11isn't.

Now Vitaly is wondering, how many excellent numbers of length exactly n are there. As this number can be rather large, he asks you to count the remainder after dividing it by 1000000007 (109 + 7).

A number's length is the number of digits in its decimal representation without leading zeroes.

Input

The first line contains three integers: a, b, n (1 ≤ a < b ≤ 9, 1 ≤ n ≤ 106).

Output

Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).

Examples

Input

1 3 3

Output

1

Input

2 3 10

Output

165

题面描述：

            这个题目输入三个整型变量，分别是a，b和n，如果一个数仅由a和b组成的话，那么这个数被称为好的数，那么如果这个数每个位上的数字加起来之和也是一个好的数的话，那么这个数就被称为一个卓越的数，现在题目问我们位数为n的正整数当中，其中卓越的数有多少个，不包含前导0。

题目分析：

            首先我们假设一个n位数包括k个a（0<=k<=n）和n-k个b，然后这个n位数各个位上的数字之和即为k*a+(n-k)*b，然后我们判断这个n位数各个位上的数字之和的这个数是否仅有a和b构成即可，如果是的话，那么总方案数加上C_{n}^{k}，如果不是的话，我们枚举下一个可能的方案，直到枚举完所有的方案后结束程序。

            注意：由于本题由于总方案数可能过大，所以要进行取模运算，所以我们要用到费马小定理去求逆元来方便求解。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
#define mod 1000000007
using namespace std;
const int Maxn=1e6+5;
ll factorial[Maxn];
ll Flt(ll temp,ll p)
{
	ll ans=1;
	while (p)
	{
		if (p&1) ans=(ans*temp)%mod;
		temp=(temp*temp)%mod;
		p>>=1;
	}
	return ans;
}
int main()
{
	int a,b,n;
	scanf("%d%d%d",&a,&b,&n);
	int sum=b*n+b-a;
	factorial[0]=1;
	for (reg int i=1;i<=n;i++) factorial[i]=(factorial[i-1]*i)%mod;
	ll ans=0;
	for (reg int i=0;i<=n;i++)
	{
		sum=sum-b+a;
		int num=sum;
		while (num)
		{
			if (num%10!=a && num%10!=b) break;
			num/=10;
		}
		if (num!=0) continue;
		ans=(ans+(factorial[n]*Flt((factorial[i]*factorial[n-i])%mod,mod-2))%mod)%mod;
	}
	printf("%lld\n",ans);
	return 0;
}

 

                                                 Q题

题面：

                                       Q - Max Factor

To improve the organization of his farm, Farmer John labels each of his N (1 <= N <= 5,000) cows with a distinct serial number in the range 1..20,000. Unfortunately, he is unaware that the cows interpret some serial numbers as better than others. In particular, a cow whose serial number has the highest prime factor enjoys the highest social standing among all the other cows. 

(Recall that a prime number is just a number that has no divisors except for 1 and itself. The number 7 is prime while the number 6, being divisible by 2 and 3, is not). 

Given a set of N (1 <= N <= 5,000) serial numbers in the range 1..20,000, determine the one that has the largest prime factor. 

Input

* Line 1: A single integer, N 

* Lines 2..N+1: The serial numbers to be tested, one per line

Output

* Line 1: The integer with the largest prime factor. If there are more than one, output the one that appears earliest in the input file.

Sample Input

4
36
38
40
42

Sample Output

38

题面描述：

            这个题目讲述的是，输入n个数，然后让我们求出这n个数当中最早出现最大质因子的数是多少。

题目分析：

            这个题目由于n比较小，而且题目输入的n个数的范围大小又不是很大，因此我们可以将n个数当中的每个数进行质因数分解，然后用一个变量与n个数当中的每个数分解出来的质因子进行比较，如果分解出来的质因子比这个变量记录的之前的那些数的最大质因子还要大的话，那么我们需要更新这个变量记录的数值，并且用一个变量记录这个当前最早出现最大质因子的数，然后把这个变量记录的答案输出即可。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
int div(int num)
{
	int ans=0;
	for (reg int i=2;i*i<=num;i++)
	{
		if (num%i!=0) continue;
		while (num%i==0) num/=i;
		ans=max(ans,i);
	}
	if (num>=1) ans=max(ans,num);
	return ans;
}
int main()
{
	int n;
	while (~scanf("%d",&n))
	{
		int ans=1,sign=1;
		for (reg int i=1;i<=n;i++)
		{
			int num,temp;
			scanf("%d",&num);
			temp=div(num);
			if (temp>ans)
			{
				ans=temp;sign=num;
			}
		}
		printf("%d\n",sign);
	}
	return 0;
}

 

                                                 R题

题面：

                                    R - Revenge of GCD

In mathematics, the greatest common divisor (gcd), also known as the greatest common factor (gcf), highest common factor (hcf), or greatest common measure (gcm), of two or more integers (when at least one of them is not zero), is the largest positive integer that divides the numbers without a remainder. 
---Wikipedia 

Today, GCD takes revenge on you. You have to figure out the k-th GCD of X and Y.

Input

The first line contains a single integer T, indicating the number of test cases. 

Each test case only contains three integers X, Y and K. 

[Technical Specification] 
1. 1 <= T <= 100 
2. 1 <= X, Y, K <= 1 000 000 000 000 

Output

For each test case, output the k-th GCD of X and Y. If no such integer exists, output -1.

Sample Input

3
2 3 1
2 3 2
8 16 3

Sample Output

1
-1
2

题面描述：

            这个题目有多组数据，然后输入两个数x和y，问我们x和y的第k大公因数是多少，如果不存在的话，就输出-1。

题目分析：

            这个题目我们首先先算出x和y的最大公因数出来，然后分情况来判断。

            第一种情况：如果x和y的最大公因数是1的话，那么我们直接可以根据k的大小来判断输出结果，如果k为1的话，那么我们就可以直接输出1；如果k大于1的话，那么我们就可以直接输出-1。

            第二种情况：如果x和y的最大公因数大于1的话，那么我们就可以从2枚举到x和y的最大公因数的开平方，来求出x和y的最大公因数的所有因子，然后再将这些因子从小到大排序，然后最后倒数第k个因子即为答案（这是因为x和y的第k大公因数肯定是x和y的最大公因数的因子），所以x和y的最大公因数的第k大因子便为答案，如果k大于x和y的最大公因数的因子个数的话，那么就输出-1即可。

            由于x和y最大可以是1e12，因此我们要用long long来储存，开平方后是1e6，再乘上数据组数后的时间复杂度大概就是O(1e8)，勉强不会超时。

            这里值得注意的是，求x和y的最大公因数的开平方需要加一个特别的判断，以避免将两个相同的开平方数重复加入。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
vector  v;
ll gcd(ll n,ll m)
{
	return n%m?gcd(m,n%m):m;
}
int main()
{
	int T;
	scanf("%d",&T);
	while (T--)
	{
		v.clear();
		ll X,Y,K,i;
		scanf("%lld%lld%lld",&X,&Y,&K);
		ll temp=gcd(min(X,Y),max(X,Y));
		v.push_back(1);
		if (temp==1)
		{
			if (K>1) printf("-1\n");else printf("1\n");
			continue;
		}
		v.push_back(temp);
		for (i=2;iv.size())
		{
			printf("-1\n");
			continue;
		}
		sort(v.begin(),v.end());
		printf("%lld\n",v[v.size()-K]);
	}
	return 0;
}

 

                                                 S题

题面：

                                           S - 美素数

　　小明对数的研究比较热爱，一谈到数，脑子里就涌现出好多数的问题，今天，小明想考考你对素数的认识。 
　　问题是这样的：一个十进制数，如果是素数，而且它的各位数字和也是素数，则称之为“美素数”，如29，本身是素数，而且2+9 = 11也是素数，所以它是美素数。 
　　给定一个区间，你能计算出这个区间内有多少个美素数吗？

Input

第一行输入一个正整数T，表示总共有T组数据(T <= 10000)。 
接下来共T行，每行输入两个整数L，R(1<= L <= R <= 1000000)，表示区间的左值和右值。

Output

对于每组数据，先输出Case数，然后输出区间内美素数的个数（包括端点值L,R）。 
每组数据占一行，具体输出格式参见样例。

Sample Input

3
1 100
2 2
3 19

Sample Output

Case #1: 14
Case #2: 1
Case #3: 4

题面描述：

            这个题目含有多组数据，每组数据输入两个变量l和r，分别代表区间的左端点与右端点，然后问我们在这个区间内有多少个美素数。所谓美素数就是满足这个数是一个素数以及这个素数的每一个数字位上的数字之和也是一个素数。

题目分析：

            这个题目输入的区间的长度最大可达1e6，然后数据组数最多有1e4组，如果直接做的话肯定会超时。

            因此我们可以先对1到1e6范围内的所有数用线性筛法把所有素数给全部筛出来，然后再把筛出来的素数的每一位分解出来相加判断是否为素数，如果是素数的话，那么就证明是美素数，那么我们可以用一个数组来这些美素数记录下来。

            经过上面的预处理后，我们只要对每组输入的数据进行如下处理即可得出答案，首先我们先求出1到r范围内美素数有多少个，由于我们在上面记录美素数的时候是有序的，因此我们可以用二分来找到一个恰好小于等于r的美素数，然后返回前面有多少个美素数即可；与上面做法一样，我们同样求出1到l-1范围内美素数的个数，最后两者相减即为答案。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
using namespace std;
int len,cnt[100005],prime[100005];
bool sign[1000005];
int solve(int num)
{
	int low=0,high=len;
	while (low<=high)
	{
		int mid=(low+high)>>1;
		if (cnt[mid]<=num) low=mid+1;else high=mid-1;
	}
	return high;
}
int main()
{
	int tot=0;len=0;
	for (reg int i=2;i<=1000000;i++)
	{
		if (!sign[i]) prime[tot++]=i;
		for (reg int j=0;j

 

                                                 T题

题面：

                                              T - A/B

要求(A/B)%9973，但由于A很大，我们只给出n(n=A%9973)(我们给定的A必能被B整除，且gcd(B,9973) = 1)。

Input

数据的第一行是一个T，表示有T组数据。 
每组数据有两个数n(0 <= n < 9973)和B(1 <= B <= 10^9)。

Output

对应每组数据输出(A/B)%9973。

Sample Input

2
1000 53
87 123456789

Sample Output

7922
6060

题面描述：

            这个题目含有多组数据，每组数据输入两个变量n和B，由于A很大，所以n=A%9973，问题要我们求的是(A/B)%9973。

题目分析：

            这个题目要求的是(A/B)%9973，由于A很大，我们可能无法求出A并且用一个整型变量取储存A，因此我们设法求出A是不可行的。

            但是经过相关转化后，我们就会发现问题会变得简单，(A/B)%9973=n*inv(B)%9973，这个式子是成立的，因此我们只需求出B的逆元然后再乘上n对9973取模后即为答案。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3fffffff
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
#define mod 9973
using namespace std;
ll Flt(ll temp,int p)
{
	ll ans=1;
	while (p)
	{
		if (p&1) ans=(ans*temp)%mod;
		temp=(temp*temp)%mod;
		p>>=1;
	}
	return ans;
}
int main()
{
	int T;
	scanf("%d",&T);
	while (T--)
	{
		int n;
		ll B;
		scanf("%d%lld",&n,&B);
		ll ans=(n*Flt(B,mod-2))%mod;
		printf("%lld\n",ans);
	}
	return 0;
}

 

                                                 U题

题面：

                                       U - 青蛙的约会

两只青蛙在网上相识了，它们聊得很开心，于是觉得很有必要见一面。它们很高兴地发现它们住在同一条纬度线上，于是它们约定各自朝西跳，直到碰面为止。可是它们出发之前忘记了一件很重要的事情，既没有问清楚对方的特征，也没有约定见面的具体位置。不过青蛙们都是很乐观的，它们觉得只要一直朝着某个方向跳下去，总能碰到对方的。但是除非这两只青蛙在同一时间跳到同一点上，不然是永远都不可能碰面的。为了帮助这两只乐观的青蛙，你被要求写一个程序来判断这两只青蛙是否能够碰面，会在什么时候碰面。 
我们把这两只青蛙分别叫做青蛙A和青蛙B，并且规定纬度线上东经0度处为原点，由东往西为正方向，单位长度1米，这样我们就得到了一条首尾相接的数轴。设青蛙A的出发点坐标是x，青蛙B的出发点坐标是y。青蛙A一次能跳m米，青蛙B一次能跳n米，两只青蛙跳一次所花费的时间相同。纬度线总长L米。现在要你求出它们跳了几次以后才会碰面。 

Input

输入只包括一行5个整数x，y，m，n，L，其中x≠y < 2000000000，0 < m、n < 2000000000，0 < L < 2100000000。

Output

输出碰面所需要的跳跃次数，如果永远不可能碰面则输出一行"Impossible"

Sample Input

1 2 3 4 5

Sample Output

4

题面描述：

            这个题目讲述的是，两只青蛙在同一纬度线上往同一方向跳，题目输入第一只青蛙的坐标x，第一只青蛙一次可以跳m米，第二只青蛙的坐标y，第二只青娃一次可以条n米，然后两只青蛙所在的纬度线长度为L米，问我们两只青蛙最少需要跳几次后可以相遇。如果两只青蛙不能相遇的话，那么就输出"Impossible"（不包括引号）。

题目分析：

            根据题目的意思，我们可以列出以下式子：

            x+u*m-y-u*n= k*L

            k*L+u*(n-m)=x-y

           由于k和u都是未知数，因此我们可以利用扩展欧几里得算法来判断解是否存在，因此我们首先利用扩展欧几里得算法求出L和n-m的最大公因数，然后判断L和n-m的最大公因数是否能整除x-y，如果可以的话，那么证明答案存在，如果不行的话，就直接输出"Impossible"（不包括引号）。

           通过扩展欧几里得算法，我们可以求出k，但是值得注意的是，这里求到的k可能是负数，因此我们需要将它转化成最小正解。

           假设存在一组解(k_{1},u_{1})满足k*L+u*(n-m)=x-y，

           假设存在另外一组解(k_{2},u_{2})满足k*L+u*(n-m)=x-y

           因此可以得出k_{1}*L+u_{1}*(n-m)=k_{2}*L+u_{2}*(n-m)

                                L*(k_{1}-k_{2})=(n-m)*(u_{2}-u_{1})

           假设g=gcd(L,n-m)，上面式子两边除以g后得，L^{'}*(k_{1}-k_{2})=(n-m)^{'}*(u_{2}-u_{1})

           L^{'}=L/g,(n-m)^{'}=(n-m)/g

           可以发现L^{'}和(n-m)^{'}是互质的，因此L^{'}是可以整除(u_{2}-u_{1})，同理，(n-m)^{'}可以整除(k_{1}-k_{2})。

           所以k*L+u*(n-m)=x-y的任意一组解可以写成(k+p*(n-m)^{'},u-p*L^{'})，因此就可以通过这样的方法来求得最小满足题目要求的正解。

代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define reg register
#define ll long long
#define ull unsigned long long
#define INF 0x3fffffff
#define min(a,b) (ab?a:b)
#define lowbit(x) (x&(-x))
#define mod 9973
using namespace std;
ll exgcd(ll a,ll &x,ll b,ll &y)
{
	if (b==0)
	{
		x=1;y=0;
		return a;
	}
	ll temp=exgcd(b,y,a%b,x);
	y-=a/b*x;
	return temp;
}
int main()
{
	ll x,y,m,n,L,t,ans;
	while (~scanf("%lld%lld%lld%lld%lld",&x,&y,&m,&n,&L))
	{
		ll gcd=exgcd(n-m,ans,L,t);
		if ((x-y)%gcd!=0 || n==m)
		{
			printf("Impossible\n");
			continue;
		}
		ans=ans*(x-y)/gcd;
		ans=(ans%(L/gcd)+L/gcd)%(L/gcd);
		printf("%lld\n",ans);
	}
	return 0;
}

 

你可能感兴趣的:(2019,GDUT,Winter,Training)

  • 抖音乐买买怎么加入赚钱?赚钱方法是什么 测评君高省
    你会在抖音买东西吗?如果会，那么一定要免费注册一个乐买买，抖音直播间，橱窗，小视频里的小黄车买东西都可以返佣金!省下来都是自己的，分享还可以赚钱乐买买是好省旗下的抖音返佣平台，乐买买分析社交电商的价值，乐买买属于今年难得的副业项目风口机会，2019年错过做好省的搞钱的黄金时期，那么2022年千万别再错过乐买买至于我为何转到高省呢？当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自
  • 2019-12-22-22:30 涓涓1016
    今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
  • 今又重阳 芮峻
    今又重阳图片发自App白露成霜菊花黄，岁岁重阳，今又重阳。登高远望，君不见，那来时路上少年，青丝已染雪霜。落日一点一点西坠，谁有力量，托住使其回往。转眼缺了大半，又能怎样？江天两茫茫。给我一壶烈酒，我要敬那斜阳，看谁先醉？笑指西天红了一片，借点酒力，老夫聊发一次少年狂。老严.2019年重阳节.杭州
  • 2019-08-08 65454
    东莞家庭聚会出行旅游去哪里玩住？想起来有很久没有和家里人聚会啦，这次组织家人来到威廉古堡别墅轰趴，一大家子27个人，在别墅订了一天办，玩的非常的开心，小孩子玩游戏机，也很放心不会丢，我们就在唱歌、打麻将、打桌球一系列的活动，还准备小次等小孩生日在别墅举办，还可以给孩子做一个生日的策划
  • 2019-3-23晨间日记 红红火火小耳朵
    今天是什么日子起床：7点40就寝：23点半天气：有太阳，不过一会儿出来一会儿进去特别清爽的凉意，还蛮舒服的心情：小激动要给女朋友过生日啦纪念日：田田女士过生日任务清单昨日完成的任务，最重要的三件事：1.英语一对一2.运动计划3.认真护肤习惯养成：调整状态周目标·完成进度英语七天打卡（5/7）轻课阅读（87/180）音标课（25/30）读书（福尔摩斯一章）学习·信息·阅读#英语课#Cookingte
  • 2019-05-13 王健_100a
    【撒下18:2】大卫打发军兵出战，分为三队：一队在约押手下，一队在洗鲁雅的儿子约押兄弟亚比筛手下，一队在迦特人以太手下。大卫对军兵说：“我必与你们一同出战。”解释：大卫检阅部队，将它分成三队，每队由一位元帅统领；约押与兄弟亚比筛，并迦特人以太共同指挥。大卫想与他们一同出战！应用：作为领袖与军兵一起出战是很重要。领袖在事奉中与信徒一起，领袖在任何的环境里与信徒一起走过。我们要同心协力为主而战。祷告：
  • 2019-11-04复盘——飞来山上千寻塔，闻说鸡鸣见日升。 那一叶秋
    1、大盘篇先上老图，看习惯了，也就知道走势了图1上证指数日线图还是那张老图，自己可以在自己的相关软件上画出来，快变盘了。2、个股篇未加仓、未减仓。分析量能的时候，突然发现这么一个东西：“放量突破年线，缩量回调。”合众科技日线图其实，最近的N只个股，在技术分析上，都到了变盘的临界时候。结合这么久的走势，特别是ZJH不断放开IPO的申请，本质上说是融资难度变大，或者说是为企业的融资开创便利。但现在市场
  • 2019-08-16 希望在东方
    《春游荣华山》春游荣华山，乍暖还寒。青苔路，石阶险。山路弯上弯！为寻古寺往幽探。细雨已润江南岸，初春芳草现。老树新芽冒枝端，人间又过到新年。今游荣华山，树茂参天，古寺悠闲。细雨飘落发端！三眼井旁，投币许心愿，并祷一世安然。更喜大女明事端，应心安，放开颜。修竹静默，雨中吐心愿。待得春风浩吹时，春笋节节攀。图片发自App图片发自App图片发自App
  • 2019-01-19 王小康KK
    姓名:王康公司:扬州市方圆建筑工程有限公司2018年3月16日～3月18日上海361期《六项精进》感谢二组学员【日精进打卡第307天】【知～学习】《六项精进》大纲3遍共862遍《大学》通篇3遍共860遍《六项精进》全书40页【经典名句】思想决定行为，行为决定习惯，习惯决定性格，性格决定命运。【行～实践】一、修身：（对自己个人）1、践行六项精进的理念。二、齐家：（对家庭和家人）1、和女朋友视频聊天。
  • 2019-10-24 柒月的可可
    今日上班无事，人又懒怠动，不知道如何打发这个下午，终于打开了。我大概是把当日记来写的。重庆的天气骤然凉了。早上出门的时候，满地都是落叶，脚踩上去，却是刚下过雨，叶子已润掉，走不出声响。白天在办公室不见天日，对温度也无甚感觉，晚上一个人回到家，屋子里窗户都开着，被冷风吹了一天，一迈进屋，便觉冷气森然。将近二十度的天气，竟要裹着毯子才觉温暖。再过一周，就到十一月。扛过十一月，就可以开暖气了。然而我真的
  • 2019考研 | 西交大软件工程 笔者阿蓉
    本科背景：某北京211学校电子信息工程互联网开发工作两年录取结果：全日制软件工程学院分数：初试350+复试笔试80+面试85+总排名：100+从五月份开始脱产学习，我主要说一下专业课和复试还有我对非全的一些看法。【数学100+】张宇，张宇，张宇。跟着张宇学习，入门视频刷一遍，真题刷两遍，错题刷三遍。书刷N多遍。从视频开始学习，是最快的学习方法。5-7月份把主要是数学学好，8-9月份开始给自己每个周
  • 2019-03-22 430O70Mk
    引发支原体的原因支原体感染是临床上比较常见的一种疾病，此疾病会对患者的身体造成很大的伤害，对支原体感染患者的日常生活也会带来极大的影响，那么诱发支原体感染的原因是什么呢?肺炎支原体感染，又称支原体性肺炎，是由肺炎支原体引起的急性间质性肺炎。主要通过呼吸道传播，健康人吸入患者咳嗽，打喷嚏时喷出的口、鼻分泌物而感染。支原体为动物多种疾病的致病体，而其中只有肺炎支原体肯定对人致病。它是由口、鼻分泌物经空
  • 今日有感，坚持分享第913天，2019.07.13 ZAF峰回路转
    本周是假日里最忙碌的一周，连续四天晚上的课程，让我感觉到身体明显透支。昨天晚上读书会结束回到家，已经是十点半之后啦，忽然感觉身体不舒服，勉强支撑着洗漱完毕，没等上床休息，强烈的不适感警告我该吃药啦！感谢老公半夜到医院給我抓了药，今天早上当我对老公表达谢意的时候，老公说，不用感谢，我不是一直都是这样做的吗？多少年啦，今天竟然还谢谢！老公说的没错，可是以前总感觉那是他应该做的，如今感觉到，身边有一个在
  • 每时每刻都是开始2019-03-09 Action熊猫
    过去有多少想了无数遍要做的，但实际并没有做到的。以没时间，或其他种种自己认为可以接受的理由，看着一天走啦，一月去啦，又是一年。最后笑一笑，新年不是来了吗！重新开始...如果在过去的365天里，每次醒来，都没能开始，那新年来了，又如何呢？何不把人生的每时每刻都作为起点，不等待，不期盼，不自欺，让每时每刻都在开始中...。
  • 2019-03-24 李飞720
    姓名：李飞企业名称：临沂鑫道食品有限公司组别373期利他1组日精进打卡第338天】【知~学习】1、阿米巴经营一段2、活用人才1段3、活法、一段【行~实践】一、修身：读书、抽烟减量、俯卧撑个跑步3公里二、齐家、劝说老爸与姑姑和好三、建功、业务洽谈【经典名句分享】1、依据原理原则追求事物的本质，以“作为人，何谓正确”进行判断2、经营者必须为员工物质和精神两方面的幸福殚精竭虑，倾尽全力，必须超脱私心，让
  • 2019年8月6日 星期二 晴 李佳晨宝宝
    今天我写完作业以后，我玩儿了一会儿我的拼装玩具，拼装玩具是我的世界的游戏里面的乐高，我拿出乐高把它拼成上次的迷宫，然后又给他升级了一下，我拆出上面一些部分的零件加大了游戏的难度，然后我又做了一个小牛圈。这个小牛圈里面住的是猪和牛，还有羊，给那里摆了一块草地，他们想吃东西直接在草地上吃，然后我把牛圈建了一个遮阳伞，防止天气太热把它们晒死。然后这样我的小牛就万无一失了，我再看看加大难度后的迷宫，实在是
  • 2019-03-10 Daisy倾夕
    生命总是需要一些允许和放纵的释怀，经常熬夜时是对自己有一份责怪，今日却又一份惊喜感！偶尔允许了自己做了一件很久没做的事情会很开心，减肥的时候会因为有一餐对食物欲望内心匮乏的填补而感到开心，偶尔的总是惊喜，长期也容易成为负担，那如何在这个长期的过程中又不失惊喜，我想应该是探索和变化的永恒，允许并好，首先先带上觉知！
  • 放松的一天 4da9b7687fa0
    20190325总结起床07:20图片发自App睡觉:23:00天气:晴今日任务清单学习·信息·阅读•水滴阅读Day40Alice’sAdventuresinWonderlandChapter6.2图片发自App•BBC跟读训练营Day24图片发自App图片发自App图片发自App•潘多拉口语训练营Day6Wow.Whatabigboy!•文化知识学习今日无•阅读时间地狱健康·饮食·锻炼•饮食目标
  • 日记 2019年10月15日 杨义博 c487bb976552
    今天是我穿校服的第一天，我很激动，我觉得我正式成为了一名一年级的小学生。中午回家时，我们看向操场发现有些高年级的大哥哥们在一个一个摆这一个有很多种颜色的龙，我们觉得很酷。下午上体育课，体育老师带我们上操场上去跑了一圈，我们看见了高年级哥哥姐姐们在操场上打鼓，还有一个大哥哥从前面拿着一个戴着星星的拐杖，指挥着全队的行动，最后面还有拿着花圈的，还有拿着国旗的。
  • 2019-01-07 遇伱
    这世上最不幸福的事情就是我等的人没有等我我关心的那个人没有关心我我想的那个人没有想我见不到的时候就会想你见到的时候就会高兴大概所有的喜欢都很相似
  • 2019-04-10 shuaigefeng
    姓名：王林锋企业名称：三亚蔚蓝时代实业有限公司组别：420期努力6组【日精进打卡251天】【知~学习、诵读】《六项精进》2遍，累计256遍《大学》2遍，累计220遍【经典分享】1、想过成功、想过失败、也想过放弃。【行~实践】一、修身：（对自己个人）1.拍打腿部两侧50下，舌顶上颚50下。2.坚持诵读、阅读。3.坚持锻炼、按时睡觉起床。4.控制健康饮食，饭后走动30分钟。5.每天反省自己的思想和行为
  • 2020年学习什么知识比较好？互联网行业依然是发展较佳 编程仔
    2019年余额已不足，不少职场人心里也在盘点这一年的工作得失，琢磨新一年的奋斗策略，是继续冲刺还是换个跑道？今年跳槽更难吗？image互联网行业一直以相对较丰厚的薪酬和广阔的发展前景吸引着各界人才。但最近，互联网行业寒冬、互联网企业裁员等话题再次引起热议。正在从前些年的高速发展期转向发展调整期的互联网行业真的步入了“寒冬”？该行业依旧具有吸引力吗？什么职位又最热门呢？image互联网行业仍保持较高
  • 2019-5-29日精进 冰女孩
    今天车辆进厂不少，天气炎热，大家都是没怎么闲着。每天工作量都不同，随时会发生不同的变化。能够在工作中不断的成长，其实多干一点也没什么，嘴笨点就得多勤快点，不能那头都不好。只要付出了，就会有回报。
  • 《驴友的朝圣》065 户外运动论坛，论户外运动之现在与未来 经典老表
    十几年来，我国户外运动蓬勃发展，已经形成全民参与热情。各类户外运动项目和形式层出不穷。各种户外运动装备产品花样百出。看着形势一派大好。但是，在这大好形势之下，仍存在着诸多的发展瓶颈及安全与管理问题，需要提请重视。为此，江城登山协会在本地召开了“户外运动论坛”，邀请市内户外运动俱乐部及体育系统领导一起研讨本地区户外运动发展的可持续性。2019年6月1日，论坛在世贸万锦大酒店的支持下，在其三层会议大厅
  • 2019 上海原创女装工作室创业一年 感悟 焦虑中带有恐慌感 女装设计师茜公子__
    时间过的太快，跟不上脚步，真不想虚度光阴，2019开春立下的FLAG，至今一条没实现！想去✈️，每每看到世界那么大，也想去看看。就像是在诉说着我的心声，再看看日益缩水的钱袋，恨自己能力有限……想去的地方太多，被现实绊住脚步，要先生存立足，才能有所谓的诗和远方……我是80的尾巴，2018年6月果断辞了工作近8年的公司，当时也是思想斗争长达几个月，断了自己的后路，当时就想再工作几年又能怎么样？锁住了自
  • 言为爱之声 胡国霞青少年超效注意力
    图片发自App焦点工作坊1期连续分享491天胡国霞20190302周六雨《言为爱声》今晚是我们七彩阳光心理咨询中心2019年的第一次公益课，由卷霞来主持，高朋满座，有老朋友，也有新朋友。李老师从身份谈起，平时父母都会给孩子一个什么样的身份，是积极的，还是消极的。我回想一下自己，我是一个追求完美的人，每看到某人身上有一项超人的技能，我都会想儿子要学会了该多好，能文能武、能弹会唱、能写能画，该多好。要
  • 2019-07-09 AutoCompleteTextView 问题 皮皮铭
    实现自定义Adapter要实现Filterable接口，不然会报错重写getFilter()方法performFiltering()方法实现过滤数据的操作publishResults()用来接收performFiltering()的返回值，发布。
  • 《爱情》 杜文霞
    杜文霞坚持原创分享第39天（20190214）图片发自App对爱情的认识我越来越清晰了。真正的爱情是成年人的游戏，双方在关系中是平等的。就像舒婷《致橡树》中写的：我如果爱你——绝不学痴情的鸟儿，为绿荫重复单调的歌曲；必须是你近旁的一株木棉，作为树的形象和你站在一起。我们共享雾霭、流岚、虹霓。仿佛永远分离，却又终身相依。爱情中的爱是相互的，是爱与被爱的流动，不是控制和占有。如果一方总觉得另一方“应该
  • 不凡的七月 让自己的心归零
    2019的七月，对于别人没什么，可对我来说，铭记在心，工作30多年的我，由于身体的原因结束我的工作生涯，退休后由于领导的契重，在公司又继续工作了三年，离职提前一个月就和领导打好招呼，我的工作是承上启下的周转站很重要，工作的严谨性和对工作态度，领导很欣赏，这一个月我尽我所能把工作做好，下个人接手好顺利进行，临别时领导又请我吃的饭，我很感动，算是给我的工作生涯画上了完美的句号。我们公司是做宠物服饰出口
  • 109期亲子践行70/90 自在飞_2b5a
    打卡日期：2019年08月4日90天打卡累计天数：70/90【宣言：超越昨天的自己，做好今天的我！先处理好情绪，再解决问题！监督员：儿子】张贺的第三个30天目标：每天早睡早起9:30-6:30妈妈的第三个30天目标:每天读书至少半小时张贺（10岁）践行打卡10/30（第三个）1.早睡早起：按照出团时间作息完成情况：外出游玩2.先吃青蛙：（1）海拉尔、满洲里游玩（2）看课外书3.️今日闪光点：（1）
  • 集合框架 天子之骄 java数据结构集合框架
       集合框架 集合框架可以理解为一个容器，该容器主要指映射(map)、集合(set)、数组(array)和列表(list)等抽象数据结构。 从本质上来说，Java集合框架的主要组成是用来操作对象的接口。不同接口描述不同的数据类型。   简单介绍：   Collection接口是最基本的接口，它定义了List和Set，List又定义了LinkLi
  • Table Driven（表驱动）方法实例 bijian1013 javaenumTable Driven表驱动
    实例一： /** * 驾驶人年龄段 * 保险行业，会对驾驶人的年龄做年龄段的区分判断 * 驾驶人年龄段：01-[18,25);02-[25,30);03-[30-35);04-[35,40);05-[40,45);06-[45,50);07-[50-55);08-[55,+∞) */ public class AgePeriodTest { //if...el
  • Jquery 总结 cuishikuan javajqueryAjaxWebjquery方法
    1.$.trim方法用于移除字符串头部和尾部多余的空格。如：$.trim('   Hello   ') // Hello2.$.contains方法返回一个布尔值，表示某个DOM元素（第二个参数）是否为另一个DOM元素（第一个参数）的下级元素。如：$.contains(document.documentElement, document.body); 3.$
  • 面向对象概念的提出 麦田的设计者 java面向对象面向过程
            面向对象中，一切都是由对象展开的，组织代码，封装数据。   在台湾面向对象被翻译为了面向物件编程，这充分说明了，这种编程强调实体。       下面就结合编程语言的发展史，聊一聊面向过程和面向对象。      c语言由贝尔实
  • linux网口绑定 被触发 linux
    刚在一台IBM Xserver服务器上装了RedHat Linux Enterprise AS 4，为了提高网络的可靠性配置双网卡绑定。 一、环境描述 我的RedHat Linux Enterprise AS 4安装双口的Intel千兆网卡，通过ifconfig -a命令看到eth0和eth1两张网卡。 二、双网卡绑定步骤： 2.1 修改/etc/sysconfig/network
  • XML基础语法 肆无忌惮_ xml
    一、什么是XML？ XML全称是Extensible Markup Language，可扩展标记语言。很类似HTML。XML的目的是传输数据而非显示数据。XML的标签没有被预定义，你需要自行定义标签。XML被设计为具有自我描述性。是W3C的推荐标准。   二、为什么学习XML？ 用来解决程序间数据传输的格式问题 做配置文件 充当小型数据库   三、XML与HTM
  • 为网页添加自己喜欢的字体 知了ing 字体 秒表 css
    @font-face { font-family: miaobiao;//定义字体名字 font-style: normal; font-weight: 400; src: url('font/DS-DIGI-e.eot');//字体文件 } 使用： <label style="font-size:18px;font-famil
  • redis范围查询应用-查找IP所在城市 矮蛋蛋 redis
    原文地址： http://www.tuicool.com/articles/BrURbqV 需求 根据IP找到对应的城市 原来的解决方案 oracle表（ip_country）： 查询IP对应的城市： 1.把a.b.c.d这样格式的IP转为一个数字，例如为把210.21.224.34转为3524648994 2. select city from ip_
  • 输入两个整数， 计算百分比 alleni123 java
    public static String getPercent(int x, int total){ double result=(x*1.0)/(total*1.0); System.out.println(result); DecimalFormat df1=new DecimalFormat("0.0000%");
  • 百合——————>怎么学习计算机语言 百合不是茶 java 移动开发
        对于一个从没有接触过计算机语言的人来说，一上来就学面向对象，就算是心里上面接受的了，灵魂我觉得也应该是跟不上的，学不好是很正常的现象，计算机语言老师讲的再多，你在课堂上面跟着老师听的再多，我觉得你应该还是学不会的，最主要的原因是你根本没有想过该怎么来学习计算机编程语言，记得大一的时候金山网络公司在湖大招聘我们学校一个才来大学几天的被金山网络录取，一个刚到大学的就能够去和
  • linux下tomcat开机自启动 bijian1013 tomcat
    方法一： 修改Tomcat/bin/startup.sh 为: export JAVA_HOME=/home/java1.6.0_27 export CLASSPATH=$CLASSPATH:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar:. export PATH=$JAVA_HOME/bin:$PATH export CATALINA_H
  • spring aop实例 bijian1013 javaspringAOP
    1.AdviceMethods.java package com.bijian.study.spring.aop.schema; public class AdviceMethods { public void preGreeting() { System.out.println("--how are you!--"); } } 2.beans.x
  • [Gson八]GsonBuilder序列化和反序列化选项enableComplexMapKeySerialization bit1129 serialization
    enableComplexMapKeySerialization配置项的含义  Gson在序列化Map时，默认情况下，是调用Key的toString方法得到它的JSON字符串的Key，对于简单类型和字符串类型，这没有问题，但是对于复杂数据对象，如果对象没有覆写toString方法，那么默认的toString方法将得到这个对象的Hash地址。   GsonBuilder用于
  • 【Spark九十一】Spark Streaming整合Kafka一些值得关注的问题 bit1129 Stream
    包括Spark Streaming在内的实时计算数据可靠性指的是三种级别： 1. At most once，数据最多只能接受一次，有可能接收不到 2. At least once, 数据至少接受一次，有可能重复接收 3. Exactly once  数据保证被处理并且只被处理一次，   具体的多读几遍http://spark.apache.org/docs/lates
  • shell脚本批量检测端口是否被占用脚本 ronin47
    #!/bin/bash cat ports |while read line do#nc -z -w 10 $line nc -z -w 2 $line 58422>/dev/null2>&1if[ $?-eq 0]then echo $line:ok else echo $line:fail fi done 这里的ports 既可以是文件
  • java-2.设计包含min函数的栈 bylijinnan java
    具体思路参见：http://zhedahht.blog.163.com/blog/static/25411174200712895228171/ import java.util.ArrayList; import java.util.List; public class MinStack { //maybe we can use origin array rathe
  • Netty源码学习-ChannelHandler bylijinnan javanetty
    一般来说，“有状态”的ChannelHandler不应该是“共享”的，“无状态”的ChannelHandler则可“共享” 例如ObjectEncoder是“共享”的, 但 ObjectDecoder 不是 因为每一次调用decode方法时，可能数据未接收完全（incomplete）， 它与上一次decode时接收到的数据“累计”起来才有可能是完整的数据，是“有状态”的 p
  • java生成随机数 cngolon java
    方法一： /** * 生成随机数 * @author [email protected] * @return */ public synchronized static String getChargeSequenceNum(String pre){ StringBuffer sequenceNum = new StringBuffer(); Date dateTime = new D
  • POI读写海量数据 ctrain 海量数据
    import java.io.FileOutputStream; import java.io.OutputStream; import org.apache.poi.xssf.streaming.SXSSFRow; import org.apache.poi.xssf.streaming.SXSSFSheet; import org.apache.poi.xssf.streaming
  • mysql 日期格式化date_format详细使用 daizj mysqldate_format日期格式转换日期格式化
    日期转换函数的详细使用说明  DATE_FORMAT(date,format) Formats the date value according to the format string. The following specifiers may be used in the format string. The&n
  • 一个程序员分享8年的开发经验 dcj3sjt126com 程序员
      在中国有很多人都认为IT行为是吃青春饭的，如果过了30岁就很难有机会再发展下去!其实现实并不是这样子的，在下从事.NET及JAVA方面的开发的也有8年的时间了，在这里在下想凭借自己的亲身经历，与大家一起探讨一下。 明确入行的目的 很多人干IT这一行都冲着“收入高”这一点的，因为只要学会一点HTML, DIV+CSS，要做一个页面开发人员并不是一件难事，而且做一个页面开发人员更容
  • android欢迎界面淡入淡出效果 dcj3sjt126com android
    很多Android应用一开始都会有一个欢迎界面，淡入淡出效果也是用得非常多的，下面来实现一下。 主要代码如下： package com.myaibang.activity; import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.os.CountDown
  • linux 复习笔记之常见压缩命令 eksliang tar解压linux系统常见压缩命令linux压缩命令tar压缩
    转载请出自出处:http://eksliang.iteye.com/blog/2109693 linux中常见压缩文件的拓展名 *.gz gzip程序压缩的文件 *.bz2 bzip程序压缩的文件 *.tar tar程序打包的数据，没有经过压缩 *.tar.gz tar程序打包后，并经过gzip程序压缩 *.tar.bz2 tar程序打包后，并经过bzip程序压缩 *.zi
  • Android 应用程序发送shell命令 gqdy365 android
    项目中需要直接在APP中通过发送shell指令来控制lcd灯，其实按理说应该是方案公司在调好lcd灯驱动之后直接通过service送接口上来给APP，APP调用就可以控制了，这是正规流程，但我们项目的方案商用的mtk方案，方案公司又没人会改，只调好了驱动，让应用程序自己实现灯的控制，这不蛋疼嘛！！！！ 发就发吧！ 一、关于shell指令： 我们知道，shell指令是Linux里面带的
  • java 无损读取文本文件 hw1287789687 读取文件无损读取读取文本文件charset
    java 如何无损读取文本文件呢？ 以下是有损的 @Deprecated public static String getFullContent(File file, String charset) { BufferedReader reader = null; if (!file.exists()) { System.out.println("getFull
  • Firebase 相关文章索引 justjavac firebase
    Awesome Firebase 最近谷歌收购Firebase的新闻又将Firebase拉入了人们的视野，于是我做了这个 github 项目。 Firebase 是一个数据同步的云服务，不同于 Dropbox 的「文件」，Firebase 同步的是「数据」，服务对象是网站开发者，帮助他们开发具有「实时」（Real-Time）特性的应用。 开发者只需引用一个 API 库文件就可以使用标准 RE
  • C++学习重点 lx.asymmetric C++笔记
    1.c++面向对象的三个特性：封装性，继承性以及多态性。   2.标识符的命名规则：由字母和下划线开头，同时由字母、数字或下划线组成；不能与系统关键字重名。   3.c++语言常量包括整型常量、浮点型常量、布尔常量、字符型常量和字符串性常量。   4.运算符按其功能开以分为六类：算术运算符、位运算符、关系运算符、逻辑运算符、赋值运算符和条件运算符。 &n
  • java bean和xml相互转换 q821424508 javabeanxmlxml和bean转换java bean和xml转换
    这几天在做微信公众号 做的过程中想找个java bean转xml的工具，找了几个用着不知道是配置不好还是怎么回事，都会有一些问题， 然后脑子一热谢了一个javabean和xml的转换的工具里，自己用着还行，虽然有一些约束吧 ， 还是贴出来记录一下      顺便你提一下下，这个转换工具支持属性为集合、数组和非基本属性的对象。   packag
  • C 语言初级 位运算 1140566087 位运算c
    第十章 位运算   1、位运算对象只能是整形或字符型数据，在VC6.0中int型数据占4个字节   2、位运算符： 运算符 作用 ~ 按位求反 << 左移 >> 右移 & 按位与 ^ 按位异或 | 按位或 他们的优先级从高到低；   3、位运算符的运算功能： a、按位取反： ~01001101 = 101
  • 14点睛Spring4.1-脚本编程 wiselyman spring4
    14.1 Scripting脚本编程 脚本语言和java这类静态的语言的主要区别是:脚本语言无需编译,源码直接可运行; 如果我们经常需要修改的某些代码,每一次我们至少要进行编译,打包,重新部署的操作,步骤相当麻烦; 如果我们的应用不允许重启,这在现实的情况中也是很常见的; 在spring中使用脚本编程给上述的应用场景提供了解决方案,即动态加载bean; spring支持脚本
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他