- 点击跳转专栏=>Unity3D特效百例
- 点击跳转专栏=>案例项目实战源码
- 点击跳转专栏=>游戏脚本-辅助自动化
- 点击跳转专栏=>Android控件全解手册
- 点击跳转专栏=>Scratch编程案例
- 点击跳转=>软考全系列
- 点击跳转=>蓝桥系列
👉关于作者
👉实践过程
需要所有整理的文档可底部卡片联系我，直接发压缩包。
😜危险系数
问题描述
抗日战争时期，冀中平原的地道战曾发挥重要作用。
地道的多个站点间有通道连接，形成了庞大的网络。但也有隐患，当敌人发现了某个站点后，其它站点间可能因此会失去联系。
我们来定义一个危险系数DF(x,y)：
对于两个站点x和y (x != y), 如果能找到一个站点z，当z被敌人破坏后，x和y不连通，那么我们称z为关于x,y的关键点。相应的，对于任意一对站点x和y，危险系数DF(x,y)就表示为这两点之间的关键点个数。
本题的任务是：已知网络结构，求两站点之间的危险系数。
输入格式
输入数据第一行包含2个整数n(2 <= n <= 1000), m(0 <= m <= 2000),分别代表站点数，通道数；
接下来m行，每行两个整数 u,v (1 <= u, v <= n; u != v)代表一条通道；
最后1行，两个数u,v，代表询问两点之间的危险系数DF(u, v)。
输出格式
一个整数，如果询问的两点不连通则输出-1.
样例输入
7 6
1 3
2 3
3 4
3 5
4 5
5 6
1 6
样例输出
2
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class Main {
static int n,m;
public static void main(String[] args) throws IOException {
BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer tok=new StringTokenizer(bfr.readLine());
// long begin=System.currentTimeMillis();
n=Integer.parseInt(tok.nextToken());
m=Integer.parseInt(tok.nextToken());
ArrayList<Integer>[] way=new ArrayList[n];
int count=0;
int i;
for(i=0;i<n;i++) way[i]=new ArrayList<Integer>();
for(i=0;i<m;i++)
{
tok=new StringTokenizer(bfr.readLine());
int x=Integer.parseInt(tok.nextToken())-1, y=Integer.parseInt(tok.nextToken())-1;
way[x].add(y); way[y].add(x);
}
tok=new StringTokenizer(bfr.readLine());
int g1=Integer.parseInt(tok.nextToken())-1, g2=Integer.parseInt(tok.nextToken())-1;
for(i=0;i<n;i++)
{
if(i==g1 || i==g2) continue;
boolean[] flag=new boolean[n];
int[] que=new int [n];
int front=0,rear=1;
que[0]=g1;
while(front<rear)
{
for(int p=0;p<way[que[front]].size();p++)
{
if(way[que[front]].get(p)==i) continue;
if (!flag[way[que[front]].get(p)])
{
que[rear] = way[que[front]].get(p);
flag[que[rear]]=true;
if(que[rear]==g2) break;
rear++;
}
}
if(flag[g2]) { count++; break; }
front++;
}
}
System.out.println(n-2-count);
// System.out.println(System.currentTimeMillis()-begin);
}
}
😜网络寻路
问题描述
X 国的一个网络使用若干条线路连接若干个节点。节点间的通信是双向的。某重要数据包，为了安全起见，必须恰好被转发两次到达目的地。该包可能在任意一个节点产生，我们需要知道该网络中一共有多少种不同的转发路径。
源地址和目标地址可以相同，但中间节点必须不同。
如下图所示的网络。
1 -> 2 -> 3 -> 1 是允许的
1 -> 2 -> 1 -> 2 或者 1 -> 2 -> 3 -> 2 都是非法的。
输入格式
输入数据的第一行为两个整数N M，分别表示节点个数和连接线路的条数(1<=N<=10000; 0<=M<=100000)。
接下去有M行，每行为两个整数 u 和 v，表示节点u 和 v 联通(1<=u,v<=N , u!=v)。
输入数据保证任意两点最多只有一条边连接，并且没有自己连自己的边，即不存在重边和自环。
输出格式
输出一个整数，表示满足要求的路径条数。
样例输入1
3 3
1 2
2 3
1 3
样例输出1
6
样例输入2
4 4
1 2
2 3
3 1
1 4
样例输出2
10
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader bfr = new BufferedReader(
new InputStreamReader(System.in));
StringTokenizer tok = new StringTokenizer(bfr.readLine());
int n = Integer.parseInt(tok.nextToken());
int m = Integer.parseInt(tok.nextToken());
int i, count = 0;
ArrayList<Integer>[] way = new ArrayList[n];
for (i = 0; i < n; i++)
way[i] = new ArrayList<Integer>();
for (i = 0; i < m; i++) {
tok = new StringTokenizer(bfr.readLine());
int x = Integer.parseInt(tok.nextToken()) - 1;
int y = Integer.parseInt(tok.nextToken()) - 1;
way[x].add(y);
way[y].add(x);
}
for (i = 0; i < n; i++) {
int a = i, ll = way[i].size();
for (int ii = 0; ii < ll; ii++) {
int aa = way[a].get(ii);
int lll = way[aa].size();
for (int iii = 0; iii < lll; iii++) {
int aaa = way[aa].get(iii);
if (aaa == a)
continue;
count += way[aaa].size();
count--;
}
}
}
System.out.println(count);
}
}
😜高僧斗法
问题描述
古时丧葬活动中经常请高僧做法事。仪式结束后，有时会有“高僧斗法”的趣味节目，以舒缓压抑的气氛。
节目大略步骤为：先用粮食（一般是稻米）在地上“画”出若干级台阶（表示N级浮屠）。又有若干小和尚随机地“站”在某个台阶上。最高一级台阶必须站人，其它任意。(如图1所示)
两位参加游戏的法师分别指挥某个小和尚向上走任意多级的台阶，但会被站在高级台阶上的小和尚阻挡，不能越过。两个小和尚也不能站在同一台阶，也不能向低级台阶移动。
两法师轮流发出指令，最后所有小和尚必然会都挤在高段台阶，再也不能向上移动。轮到哪个法师指挥时无法继续移动，则游戏结束，该法师认输。
对于已知的台阶数和小和尚的分布位置，请你计算先发指令的法师该如何决策才能保证胜出。
输入格式
输入数据为一行用空格分开的N个整数，表示小和尚的位置。台阶序号从1算起，所以最后一个小和尚的位置即是台阶的总数。（N<100, 台阶总数<1000）
输出格式
输出为一行用空格分开的两个整数: A B, 表示把A位置的小和尚移动到B位置。若有多个解，输出A值较小的解，若无解则输出-1。
样例输入
1 5 9
样例输出
1 4
样例输入
1 5 8 10
样例输出
1 3
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer tok= new StringTokenizer(bfr.readLine());
int i=0,j,flag=1;
int[] monk=new int[108];
while(tok.hasMoreTokens()) monk[i++]=Integer.parseInt(tok.nextToken());
int N=i-1;
int[] A=new int[N];
for(i=0;i<N;i++) A[i]=monk[i+1]-monk[i]-1;
int sum=A[0];
for(i=2;i<N;i++,i++) sum^=A[i];
if(sum==0) System.out.println(-1);
else
{
for(i=0;i<N;i++)
{
for(j=1;j<=A[i];j++)
{
int s=sum;
A[i]-=j;
if(i>0) A[i-1]+=j;
if(i%2==0) { s^=(A[i]+j); s^=A[i]; }
else { s^=(A[i-1]-j); s^=A[i-1]; }
if(s==0) { System.out.println(monk[i]+" "+(monk[i]+j)); flag=0; break; }
else { A[i]+=j; if(i>0) A[i-1]-=j; }
}
if(flag==0) break;
}
}
}
}
😜约数倍数选卡片
问题描述
闲暇时，福尔摩斯和华生玩一个游戏：
在N张卡片上写有N个整数。两人轮流拿走一张卡片。要求下一个人拿的数字一定是前一个人拿的数字的约数或倍数。例如，某次福尔摩斯拿走的卡片上写着数字“6”，则接下来华生可以拿的数字包括：
1，2，3, 6，12，18，24 …
当轮到某一方拿卡片时，没有满足要求的卡片可选，则该方为输方。
请你利用计算机的优势计算一下，在已知所有卡片上的数字和可选哪些数字的条件下，怎样选择才能保证必胜！
当选多个数字都可以必胜时，输出其中最小的数字。如果无论如何都会输，则输出-1。
输入格式
输入数据为2行。第一行是若干空格分开的整数（每个整数介于1~100间），表示当前剩余的所有卡片。
第二行也是若干空格分开的整数，表示可以选的数字。当然，第二行的数字必须完全包含在第一行的数字中。
输出格式
程序则输出必胜的招法！！
样例输入
2 3 6
3 6
样例输出
3
样例输入
1 2 2 3 3 4 5
3 4 5
样例输出
4
import java.util.Arrays;
import java.util.Scanner;
public class Main{
static int[] cnt=new int[101];
static int[] end=new int[101];
public static boolean f(int[][] table,int x){
for(int i=end[x];i>=0;i--) {
int j=table[x][i];
if(cnt[j]>0){
cnt[j]--;
if(f(table,j)){
cnt[j]++;
return false;
}
cnt[j]++;
}
}
return true;
}
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String[] s1=sc.nextLine().split(" ");
String[] s2=sc.nextLine().split(" ");
int[] m=new int[s2.length];
int[][] table=new int[101][100];
for (int i = 0; i < s1.length; i++) {
int x=Integer.parseInt(s1[i]);
cnt[x]++;
}
for (int i = 1; i < 101; i++) {
if(cnt[i]>0){
int t=0;
for (int j = 1; j <=100; j++) {
if(cnt[j]>0 && (i%j==0||j%i==0))
{
table[i][t]=j;
t++;
}
}
end[i]=t-1;
}
}
for (int i = 0; i < s2.length; i++) {
m[i]=Integer.parseInt(s2[i]);
}
Arrays.sort(m);
for (int i = 0; i < m.length; i++) {
cnt[m[i]]--;
if(f(table,m[i])){
System.out.println(m[i]);
return;
}
cnt[m[i]]++;
}
System.out.println(-1);
}
}
👉其他
温馨提示：点击下方卡片获取更多意想不到的资源。
