//List<Integer> path =new LinkedList<>(); LinkedList<Integer> path = new LinkedList<>();两种定义方法的区别
时间: 2024-01-01 21:14:19 浏览: 43
这两种定义方式的区别在于,List是一个接口,而LinkedList是List接口的一个实现类。因此,第一种定义方式创建的是一个List类型的对象,不能直接调用LinkedList特有的方法;而第二种定义方式创建的是一个LinkedList类型的对象,可以直接调用LinkedList特有的方法。另外,由于LinkedList是List的一个实现类,因此LinkedList对象也可以赋值给List类型的变量。
相关问题
class Solution { public int[][] findContinuousSequence(int target) { List<Integer> path = new LinkedList(); List<List<Integer>> res = new LinkedList(); for(int i = 1;i < target;i++){ int sum = 0; for(int j = i;j < target;j++){ sum+=j; if(sum > target)continue; else if(sum == target){ path.add(j); } } if(!path.isRmpty()){ res.add(path); } } } }
这段代码是一个 Java 中的类 `Solution`,其中包含了一个名为 `findContinuousSequence` 的方法,该方法接收一个整数参数 `target`,返回一个二维整数数组。
实现思路是:从 1 开始遍历到 `target` 的前一个数,对于每个数 `i`,从 `i` 开始往后累加数,直到累加和超过 `target` 或者到达 `target` 本身。如果累加和等于 `target`,那么就把累加的数存储到 `path` 列表中。最后将 `path` 列表添加到 `res` 列表中。最终返回 `res` 列表。
需要注意的是,代码中存在一些问题:
1. `path` 和 `res` 列表没有初始化,需要在方法内部进行初始化,例如 `List<Integer> path = new LinkedList<>()`。
2. 在内层循环中,应该判断 `sum` 是否大于等于 `target`,如果大于等于,就不需要再往下累加了,应该直接退出内层循环,进行下一个数的累加。
3. 在判断 `path` 列表是否为空时,应该使用 `path.isEmpty()`,而不是 `path.isRmpty()`。
给你两个素数,请问,你能否从第一个变换到第二个?变换规则如下: 每次将当前素数的某一位换掉,成为一个新的素数写一个java程序
我可以回答这个问题。以下是一个Java程序,可以将一个素数变换为另一个素数:
import java.util.*;
public class PrimeTransformer {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入第一个素数:");
int prime1 = scanner.nextInt();
System.out.print("请输入第二个素数:");
int prime2 = scanner.nextInt();
if (!isPrime(prime1) || !isPrime(prime2)) {
System.out.println("输入的不是素数!");
return;
}
if (prime1 == prime2) {
System.out.println("两个素数相同,无需变换!");
return;
}
if (getDigits(prime1) != getDigits(prime2)) {
System.out.println("两个素数位数不同,无法变换!");
return;
}
List<Integer> primes = generatePrimes(getDigits(prime1));
Map<Integer, List<Integer>> graph = buildGraph(primes);
List<Integer> path = findShortestPath(graph, prime1, prime2);
if (path == null) {
System.out.println("无法从第一个素数变换到第二个素数!");
return;
}
System.out.println("变换路径为:" + path);
}
private static boolean isPrime(int n) {
if (n <= 1) {
return false;
}
for (int i = 2; i <= Math.sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
private static int getDigits(int n) {
return (int) Math.log10(n) + 1;
}
private static List<Integer> generatePrimes(int digits) {
int start = (int) Math.pow(10, digits - 1);
int end = (int) Math.pow(10, digits) - 1;
List<Integer> primes = new ArrayList<>();
for (int i = start; i <= end; i++) {
if (isPrime(i)) {
primes.add(i);
}
}
return primes;
}
private static Map<Integer, List<Integer>> buildGraph(List<Integer> primes) {
Map<Integer, List<Integer>> graph = new HashMap<>();
for (int i = 0; i < primes.size(); i++) {
for (int j = i + 1; j < primes.size(); j++) {
if (canTransform(primes.get(i), primes.get(j))) {
graph.computeIfAbsent(primes.get(i), k -> new ArrayList<>()).add(primes.get(j));
graph.computeIfAbsent(primes.get(j), k -> new ArrayList<>()).add(primes.get(i));
}
}
}
return graph;
}
private static boolean canTransform(int prime1, int prime2) {
int digits = getDigits(prime1);
int diff = 0;
for (int i = 0; i < digits; i++) {
if (prime1 % 10 != prime2 % 10) {
diff++;
}
prime1 /= 10;
prime2 /= 10;
}
return diff == 1;
}
private static List<Integer> findShortestPath(Map<Integer, List<Integer>> graph, int start, int end) {
Queue<Integer> queue = new LinkedList<>();
Map<Integer, Integer> distance = new HashMap<>();
Map<Integer, Integer> parent = new HashMap<>();
queue.offer(start);
distance.put(start, 0);
parent.put(start, null);
while (!queue.isEmpty()) {
int curr = queue.poll();
if (curr == end) {
break;
}
for (int neighbor : graph.get(curr)) {
if (!distance.containsKey(neighbor)) {
queue.offer(neighbor);
distance.put(neighbor, distance.get(curr) + 1);
parent.put(neighbor, curr);
}
}
}
if (!parent.containsKey(end)) {
return null;
}
List<Integer> path = new ArrayList<>();
int curr = end;
while (curr != null) {
path.add(curr);
curr = parent.get(curr);
}
Collections.reverse(path);
return path;
}
}
输入第一个素数和第二个素数后,程序会自动计算它们之间的变换路径。例如,如果输入11和31,程序会输出:
变换路径为:[11, 31]
这意味着可以通过一次变换将11变成31,变换的过程是将第二位上的1替换为3。
相关推荐
![text/x-java](https://img-home.csdnimg.cn/images/20210720083646.png)
![zip](https://img-home.csdnimg.cn/images/20210720083736.png)
![pdf](https://img-home.csdnimg.cn/images/20210720083512.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)