一、问题 1441: [蓝桥杯][2013年第四届真题]幸运数
时间限制: 1Sec 内存限制: 128MB 提交: 432 解决: 192
题目描述
幸运数是波兰数学家乌拉姆命名的。它采用与生成素数类似的“筛法”生成
。
首先从1开始写出自然数1,2,3,4,5,6,…
1 就是第一个幸运数。
我们从2这个数开始。把所有序号能被2整除的项删除，变为：
1 _ 3 _ 5 _ 7 _ 9 …
把它们缩紧，重新记序，为：
1 3 5 7 9 … 。这时，3为第2个幸运数，然后把所有能被3整除的序号位置的数删去。注意，是序号位置，不是那个数本身能否被3整除!! 删除的应该是5，11, 17, …
此时7为第3个幸运数，然后再删去序号位置能被7整除的(19,39,…)
最后剩下的序列类似：
1, 3, 7, 9, 13, 15, 21, 25, 31, 33, 37, 43, 49, 51, 63, 67, 69, 73, 75, 79, …
输入
输入两个正整数m n, 用空格分开 (m < n < 1000*1000)
输出
程序输出 位于m和n之间的幸运数的个数（不包含m和n）。
样例输入
30 69
样例输出
8
注意：我只是把从0开始改成从t-1开始，答案就从超时20%变为正确了…这是一个很值得注意的地方
package day7;
import java.util.LinkedList;
import java.util.Scanner;
public class t1441 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int m=sc.nextInt();
int n=sc.nextInt();
LinkedList<Integer> ll=new LinkedList<Integer>();
for(int i=1;i<=n;i++){
if(i%2!=0){
ll.add(i);
}
}
for(int j=1;j<ll.size();j++){
int t=ll.get(j);
// System.out.println(t);
for(int i=t-1;i<ll.size();i++){
if((i+1)%t==0){
ll.set(i, -1);
}
}
// for(int i=0;i<ll.size();i++){
// System.out.print(ll.get(i)+" ");
// }
// System.out.println();
for(int i=t-1;i<ll.size();i++){
if(ll.get(i)==-1){
ll.remove(i);
}
}
if(ll.size()<j){
break;
}
}
int res=0;
for(int i=0;i<ll.size();i++){
if(ll.get(i)>m&&ll.get(i)<n){
res++;
}
}
System.out.println(res);
}
}
二、通过阶乘熟悉对BigInteger的使用
package day7;
import java.math.BigInteger;
public class BigInteger_test {
public static void main(String[] args) {
BigInteger s=new BigInteger("10");
BigInteger ling=new BigInteger("0");
BigInteger bi=new BigInteger("5");
BigInteger res=new BigInteger("1");
while(bi.compareTo(ling)==1){
res=res.multiply(bi);
// while(res.mod(s).equals(ling)){
// res=res.divide(s);
// }
bi=bi.add(new BigInteger("-1"));
}
System.out.println(res);
}
}
三、dijkstra算法（输出A到各点的最短路，仅适用于非负权图）
bfs只能解决不带权图或均值相等的图
基本思想：
通过Dijkstra计算图G中的最短路径时，需要指定起点s(即从顶点s开始计算)。
此外，引进两个集合S和U。S的作用是记录已求出最短路径的顶点(以及相应的最短路径长度)，而U则是记录还未求出最短路径的顶点(以及该顶点到起点s的距离)。
初始时，S中只有起点s；U中是除s之外的顶点，并且U中顶点的路径是"起点s到该顶点的路径"。然后，从U中找出路径最短的顶点，并将其加入到S中；接着，更新U中的顶点和顶点对应的路径。 然后，再从U中找出路径最短的顶点，并将其加入到S中；接着，更新U中的顶点和顶点对应的路径。 … 重复该操作，直到遍历完所有顶点。
代码1/3：Vertex.java
package dijkstra;
public class Vertex implements Comparable<Vertex>{
/*** 节点名称(A,B,C,D)*/
private String name;
/*** 最短路径长度*/
private int path;
/*** 节点是否已经出列(是否已经处理完毕)*/
private boolean isMarked;
public Vertex(String name){
this.name = name;
this.path = Integer.MAX_VALUE; //初始设置为无穷大
this.setMarked(false);
}
public Vertex(String name, int path){
this.name = name;
this.path = path;
this.setMarked(false);
}
public void setMarked(boolean b) {
// TODO Auto-generated method stub
this.isMarked=b;
}
public boolean isMarked(){
return this.isMarked;
}
public int getPath(){
return this.path;
}
public void setPath(int path){
this.path=path;
}
@Override
public int compareTo(Vertex o) {
return o.path > path?-1:1;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return name+" "+path;
}
}
代码2/3: Graph.java
package dijkstra;
import java.util.ArrayList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
public class Graph {
/** 顶点*/
private List<Vertex> vertexs;
/** 边*/
private int[][] edges;
/** 没有访问的顶点*/
private Queue<Vertex> unVisited;
public Graph(List<Vertex> vertexs, int[][] edges) {
this.vertexs = vertexs;
this.edges = edges;
initUnVisited();
}
/** 搜索各顶点最短路径*/
public void search(){
while(!unVisited.isEmpty()){
Vertex vertex = unVisited.element();
//顶点已经计算出最短路径，设置为"已访问"
vertex.setMarked(true);
//获取所有"未访问"的邻居
List<Vertex> neighbors = getNeighbors(vertex);
//更新邻居的最短路径
updatesDistance(vertex, neighbors);
pop();
}
for(Vertex v: vertexs){
System.out.println(v);
}
System.out.println("search over");
}
/*
* 更新所有邻居的最短路径
*/
private void updatesDistance(Vertex vertex, List<Vertex> neighbors){
for(Vertex neighbor: neighbors){
updateDistance(vertex, neighbor);
}
}
/*
* 更新邻居的最短路径
*/
private void updateDistance(Vertex vertex, Vertex neighbor){
int distance = getDistance(vertex, neighbor) + vertex.getPath();
if(distance < neighbor.getPath()){
neighbor.setPath(distance);
}
}
/*
* 初始化未访问顶点集合
*/
private void initUnVisited() {
unVisited = new PriorityQueue<Vertex>();
for (Vertex v : vertexs) {
unVisited.add(v);
}
}
/*
* 从未访问顶点集合中删除已找到最短路径的节点
*/
private void pop() {
unVisited.poll();
}
/*
* 获取顶点到目标顶点的距离
*/
private int getDistance(Vertex source, Vertex destination) {
int sourceIndex = vertexs.indexOf(source);
int destIndex = vertexs.indexOf(destination);
return edges[sourceIndex][destIndex];
}
/*
* 获取顶点所有(未访问的)邻居
*/
private List<Vertex> getNeighbors(Vertex v) {
List<Vertex> neighbors = new ArrayList<Vertex>();
int position = vertexs.indexOf(v);
Vertex neighbor = null;
int distance;
for (int i = 0; i < vertexs.size(); i++) {
if (i == position) {
//顶点本身，跳过
continue;
}
distance = edges[position][i]; //到所有顶点的距离
if (distance < Integer.MAX_VALUE) {
//是邻居(有路径可达)
neighbor = getVertex(i);
if (!neighbor.isMarked()) {
//如果邻居没有访问过，则加入list;
neighbors.add(neighbor);
}
}
}
return neighbors;
}
/*
* 根据顶点位置获取顶点
*/
private Vertex getVertex(int index) {
return vertexs.get(index);
}
/*
* 打印图
*/
public void printGraph() {
int verNums = vertexs.size();
for (int row = 0; row < verNums; row++) {
for (int col = 0; col < verNums; col++) {
if(Integer.MAX_VALUE == edges[row][col]){
System.out.print("&");
System.out.print(" ");
continue;
}
System.out.print(edges[row][col]);
System.out.print(" ");
}
System.out.println();
}
}
}
代码3/3 : Test.java
package dijkstra;
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args){
List<Vertex> vertexs = new ArrayList<Vertex>();
Vertex a = new Vertex("A", 0);
Vertex b = new Vertex("B");
Vertex c = new Vertex("C");
Vertex d = new Vertex("D");
Vertex e = new Vertex("E");
Vertex f = new Vertex("F");
vertexs.add(a);
vertexs.add(b);
vertexs.add(c);
vertexs.add(d);
vertexs.add(e);
vertexs.add(f);
int[][] edges = {
{Integer.MAX_VALUE,3,4,Integer.MAX_VALUE,Integer.MAX_VALUE,Integer.MAX_VALUE},
{Integer.MAX_VALUE,Integer.MAX_VALUE,Integer.MAX_VALUE,7,Integer.MAX_VALUE,Integer.MAX_VALUE},
{3,Integer.MAX_VALUE,Integer.MAX_VALUE,5,6,Integer.MAX_VALUE},
{4,7,5,Integer.MAX_VALUE,3,2},
{Integer.MAX_VALUE,Integer.MAX_VALUE,6,3,Integer.MAX_VALUE,6},
{Integer.MAX_VALUE,2,Integer.MAX_VALUE,Integer.MAX_VALUE,6,Integer.MAX_VALUE}
};
Graph graph = new Graph(vertexs, edges);
// graph.printGraph();
graph.search();
}
}
四、SPFA算法
（最好还是用dijkstra算法，SPFA可以用于有负权的图，但不可用于有负环的图）
类似bfs算法
来源
何为spfa（Shortest Path Faster Algorithm）算法？
spfa算法功能：给定一个加权连通图，选取一个顶点，称为起点，求取起点到其它所有顶点之间的最短距离，其显著特点是可以求含负权图的单源最短路径，且效率较高。（PS：引用自百度百科：spfa是求单源最短路径的一种算法，它还有一个重要的功能是判负环（在差分约束系统中会得以体现），在Bellman-ford算法的基础上加上一个队列优化，减少了冗余的松弛操作，是一种高效的最短路算法。）
spfa算法思想：spfa就是BellmanFord的一种实现方式，其具体不同在于，对于处理松弛操作时，采用了队列（先进先出方式）操作，从而大大提高了时间复杂度。
package com.liuzhen.chapter9;
import java.util.ArrayList;
import java.util.Scanner;
public class Spfa {
public long[] result; //用于得到第s个顶点到其它顶点之间的最短距离
//内部类，用于存放图的具体边数据
class edge {
public int a; //边的起点
public int b; //边的终点
public int value; //边的权值
edge(int a, int b, int value) {
this.a = a;
this.b = b;
this.value = value;
}
}
/*
* 参数n:给定图的顶点个数
* 参数s:求取第s个顶点到其它所有顶点之间的最短距离
* 参数edge:给定图的具体边
* 函数功能：如果给定图不含负权回路，则可以得到最终结果，如果含有负权回路，则不能得到最终结果
*/
public boolean getShortestPaths(int n, int s, edge[] A) {
ArrayList<Integer> list = new ArrayList<Integer>();
result = new long[n];
boolean[] used = new boolean[n];
int[] num = new int[n];
for(int i = 0;i < n;i++) {
result[i] = Integer.MAX_VALUE;
used[i] = false;
}
result[s] = 0; //第s个顶点到自身距离为0
used[s] = true; //表示第s个顶点进入数组队
num[s] = 1; //表示第s个顶点已被遍历一次
list.add(s); //第s个顶点入队
while(list.size() != 0) {
int a = list.get(0); //获取数组队中第一个元素
list.remove(0); //删除数组队中第一个元素
for(int i = 0;i < A.length;i++) {
//当list数组队的第一个元素等于边A[i]的起点时
if(a == A[i].a && result[A[i].b] > result[A[i].a] + A[i].value) {
result[A[i].b] = result[A[i].a] + A[i].value;
if(!used[A[i].b]) {
list.add(A[i].b);
num[A[i].b]++;
if(num[A[i].b] > n)
return false;
used[A[i].b] = true; //表示边A[i]的终点b已进入数组队
}
}
}
used[a] = false; //顶点a出数组对
}
return true;
}
public static void main(String[] args) {
Spfa test = new Spfa();
Scanner in = new Scanner(System.in);
System.out.println("请输入一个图的顶点总数n起点下标s和边总数p：");
int n = in.nextInt();
int s = in.nextInt();
int p = in.nextInt();
edge[] A = new edge[p];
System.out.println("请输入具体边的数据：");
for(int i = 0;i < p;i++) {
int a = in.nextInt();
int b = in.nextInt();
int value = in.nextInt();
A[i] = test.new edge(a, b, value);
}
if(test.getShortestPaths(n, s, A)) {
for(int i = 0;i < test.result.length;i++)
System.out.print(test.result[i]+" ");
} else
System.out.println("给定图存在负环，没有最短距离");
}
}
五、Floyd算法（可以用于负环图，可以算出任意两点之间的最短路）
来源
代码：
package Floyd;
public class ShortestPathFloyd {
/** 邻接矩阵 */
private int[][] matrix;
/** 表示正无穷 */
private int MAX_WEIGHT = Integer.MAX_VALUE;
/**路径矩阵*/
private int[][] pathMatirx;
/**前驱表*/
private int[][] preTable;
/**
* 创建图1
*/
private void createGraph1(int index) {
matrix = new int[index][index];
int[] v0 = { 0, 1, MAX_WEIGHT, MAX_WEIGHT, 2, MAX_WEIGHT };
int[] v1 = { 1, 0, 1, MAX_WEIGHT, MAX_WEIGHT, MAX_WEIGHT };
int[] v2 = { MAX_WEIGHT, 1, 0, 1, MAX_WEIGHT, MAX_WEIGHT };
int[] v3 = { MAX_WEIGHT, MAX_WEIGHT, 1, 0, 1, MAX_WEIGHT };
int[] v4 = { MAX_WEIGHT, MAX_WEIGHT, MAX_WEIGHT, 1, 0, 1 };
int[] v5 = { MAX_WEIGHT, MAX_WEIGHT, MAX_WEIGHT, 1, 1, 0 };
matrix[0] = v0;
matrix[1] = v1;
matrix[2] = v2;
matrix[3] = v3;
matrix[4] = v4;
matrix[5] = v5;
}
public void floyd(){
//路径矩阵（D），表示顶点到顶点的最短路径权值之和的矩阵，初始时，就是图的邻接矩阵。
pathMatirx = new int[matrix.length][matrix.length];
//前驱表（P），P[m][n] 的值为 m到n的最短路径的前驱顶点，如果是直连，值为n。也就是初始值
preTable = new int[matrix.length][matrix.length];
//初始化D,P
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix.length; j++) {
pathMatirx[i][j] = matrix[i][j];
preTable[i][j] = j;
}
}
//循环 中间经过顶点
for (int k = 0; k < matrix.length; k++) {
//循环所有路径
for (int m = 0; m < matrix.length; m++) {
for (int n = 0; n < matrix.length; n++) {
int mn = pathMatirx[m][n];
int mk = pathMatirx[m][k];
int kn = pathMatirx[k][n];
int addedPath = (mk == MAX_WEIGHT || kn == MAX_WEIGHT)? MAX_WEIGHT : mk + kn;
if (mn > addedPath) {
//如果经过k顶点路径比原两点路径更短，将两点间权值设为更小的一个
pathMatirx[m][n] = addedPath;
//前驱设置为经过下标为k的顶点
preTable[m][n] = preTable[m][k];
}
}
}
}
}
/**
* 打印 所有最短路径
*/
public void print() {
for (int m = 0; m < matrix.length; m++) {
for (int n = m + 1; n < matrix.length; n++) {
int k = preTable[m][n];
System.out.print("(" + m + "," + n + ")" + pathMatirx[m][n] + ": ");
System.out.print(m);
while (k != n) {
System.out.print("->" + k);
k = preTable[k][n];
}
System.out.println("->" + n);
}
System.out.println();
}
}
public static void main(String[] args) {
ShortestPathFloyd floyd = new ShortestPathFloyd();
floyd.createGraph1(6);
floyd.floyd();
floyd.print();
}
}
扫一扫
3768
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
