「java算法题吃菜问题」java算法工程师
本篇文章给大家谈谈java算法题吃菜问题，以及java算法工程师对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、关于Java语言的简单问题
- 2、java算法题。小菜鸟的大问题。面试题。
- 3、Java简单算法问题
- 4、一个有关于java的算法问题，求高手协做
- 5、java经典算法题——猴子吃桃
- 6、java算法设计问题（贪心算法）
关于Java语言的简单问题
1、不能。内存泄露和死循环、程序崩溃都是因为程序员的原因，没有任何一款软件或者语言能做到避免。
2、java现在出到java2，另外，java是一种语言，而你说的vc++那是一个开发工具。。。这两个怎么比？难道能说c++比Eclipse优秀？
3、学完c++以后再学java很明显的一点就是程序的错误会少，因为c++面向底层的能力使得它的代码出现bug的几率要比java多。如果反过来则错误会很多。再说一遍：程序崩溃时程序员设计的问题，跟语言无关！
4、编程效率分为开发效率和运行效率,开发效率最高的我认为还是java,然后是c#,然后才是c++;运行效率是c++,c#和java(很多人认为c#的运行效率已经不次于c++了,这点没有多少人证明,姑且听之).特点:java开发简单,c++运行高效,c#语法与java及其相似,另外效率要比java高很多.
5、这点无法跟你说。人家用几本书才能说明的问题，这里也不可能通过几百字能给你解释清楚。看看java编程思想还是不错的。
6、安全性。如果要从语言上限制的话，当然是java最好了，因为它不提供直接访问底层的功能，所以安全性要稍微高些。不过，java也能编写危险的程序，所以，安全性并不是由语言带来的，要不然java语言一出，世界上的软件安全检测员都失业算了！安全性来自于程序员的设计，自己多练练吧！
java算法题。小菜鸟的大问题。面试题。
帮你写出来了：用 欧几里得最大公约数 算法，然后判断：
如果分子 = 分母或者 gcd 结果 b 值不是 1 就不是最简真分数，否则就是。
我这个用正则表达式先判断输入格式了。
---------------------------------------------------------------
import java.util.regex.Pattern;
import java.io.*;
public class Demo {
public static void main (String args[]) throws IOException {
Pattern regex = Pattern.compile("[0-9]*/[0-9]*");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String num = "";
while (!(num = br.readLine()).equals("-1")) {
if (!regex.matcher(num).matches()) {
System.out.println("格式不正确，请重新输入！");
continue;
}
int a = Integer.parseInt(num.substring(0, num.indexOf('/')));
int b = Integer.parseInt(num.substring(num.indexOf('/')+1));
if (a = b || !isRelativelyPrime(a, b))
System.out.println(num + "不是最简真分数");
else
System.out.println(num + "是最简真分数");
}
}
private static boolean isRelativelyPrime (int a, int b) {
int tmp = 0;
while (a 0) {
tmp = b % a;
b = a;
a = tmp;
}
if (b == 1)
return true;
else
return false;
}
}
----------------------------- 运行结果 -------------------------------
Java简单算法问题
初步做了一个出来，但是效率并不是很高，前100个计算速度还可以，但是往后就很慢了。如果什么时候有空的话可以再看看，先给你代码吧，不知道能不能帮上你
public class AlisandaNumber {
private static final int MAX_INDEX = 1000; // 可以先把这个常量改为1-6，验证正确性
public static void main(String[] args) {
int a = 0;
int index = 0;
while(index MAX_INDEX) {
a += 6; // 每次循环自增6，由题目规律可知A是6的倍数
boolean breakOut = false;
// 最大的约数为此数的平方根，因为如果是两个平方根相乘的话，剩下的就只有1了
int maxNum = (int) Math.ceil(Math.sqrt(a));
p:
for(int p = 1; p = maxNum; p ++) {
if(a % p != 0) {
continue; // 如果不是约数的话，没必要考虑，下同
}
// 最大约数为平方根的相反数，原理同上
maxNum = (int) Math.ceil(Math.sqrt(a / p));
for(int q = -1; q = -maxNum; q --) { // q和r必为负数
if(a % q != 0) {
continue;
}
int r = a / (p * q);
int nonZero = p * q + p * r + q * r;
if (nonZero == 0) {
continue;
}
if((a == p * q * r) (a == (p * q * r) / (nonZero))) {
index ++;
breakOut = true;
break p; // 跳出外层循环
}
}
}
if(breakOut) {
System.out.println(String.format("第%d个压力山大数是%d", index, a));
}
}
}
}
一个有关于java的算法问题，求高手协做
//参考别人的,自己就懒得写了,你拿去参考参考...
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Dijkstra {
private int[][] graph;// 加权有向图
private int start;// 源点编号 从 0开始
private int dimention;
static int INF = Integer.MAX_VALUE / 100;
// 用于标记顶点是否已经计算
private SetInteger vertexSet = new HashSetInteger();
// 存储结果，Map的key对应各终点编号，value对应路径编号列表。
private MapInteger, ListInteger pathListMap = new HashMapInteger, ListInteger();
public Dijkstra(int[][] graph, int start) {
this.graph = graph;
this.start = start;
this.dimention = graph.length;
calculate();
}
private void calculate() {
// 初始化
for (int end = 0; end dimention; end++) {
if (end == start) {
continue;
}// 起始点自己的路径排除。
ListInteger pathList = new ArrayListInteger();
pathList.add(start);// 每条路径的起始点都为start，pathList只记录编号，不记录路径权值
pathList.add(end);// 每条路径的第二个参数为终点编号
pathListMap.put(end, pathList);
}
// 计算主体
for (int bridge = 0; bridge dimention; bridge++) {
if (bridge == start) {
continue;
}
if (!vertexSet.contains(bridge)) {// 确保每个基点只循环计算一次
for (int next = 0; next dimention; next++) {
if (next == start || next == bridge) {
continue;
}
if (startTo(bridge) + getRawLength(bridge, next) startTo(next)) {
ListInteger pathList = pathListMap.get(next);
ListInteger bridgePathList = pathListMap.get(bridge);
// 清空，使用新的
pathList.clear();
pathList.addAll(bridgePathList);
pathList.add(next);
}
}
}
vertexSet.add(bridge);
}
// 检查，是否桥接的路径都被更新
for (int end = 0; end dimention; end++) {
if (end == start) {
continue;
}
ListInteger pathList = pathListMap.get(end);
int size = pathList.size();
if (size 2) {
for (int end2 = 0; end2 dimention; end2++) {
int isEnd = pathList.get(size - 2);
if (end2 == isEnd) {
pathList.clear();
pathList.addAll(pathListMap.get(end2));
pathList.add(end);
}
}
}
}
}
private int startTo(int end) {
int pathLen = 0;
ListInteger pathList = pathListMap.get(end);
for (int i = 0; i pathList.size() - 1; i++) {
pathLen += graph[pathList.get(i)][pathList.get(i + 1)];
}
return pathLen;
}
private int getRawLength(int start, int end) {
if (end == start) {
return 0;
}
return graph
本篇文章给大家谈谈java算法题吃菜问题，以及java算法工程师对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
关于java算法题吃菜问题和java算法工程师的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
;}
public int getLength(int end) {
if (end == start) {
return 0;
}
return startTo(end);
}
public void printResult() {
System.out.println(pathListMap);
}
public MapInteger, ListInteger getPathListMap() {
return pathListMap;
}
public static void main(String[] args) {
/*
* int [][] graph = { { INF, 10, INF, 30, 100}, { INF, INF, 50, INF,
* INF}, { INF, INF, INF, INF, 10}, { INF, INF, 20, INF, 60}, { INF,
* INF, INF, INF, INF}};
*/
int[][] graph = { { INF, INF, 10, INF, 30, 100 },
{ INF, INF, 5, INF, INF, INF },
{ INF, INF, INF, 50, INF, INF },
{ INF, INF, INF, INF, INF, 10 },
{ INF, INF, INF, 20, INF, 60 },
{ INF, INF, INF, INF, INF, INF }, };
int start = 0;
int end = 0;
int length = graph.length;
for (start = 0; start length; start++) {
System.out.println();
Dijkstra dijkstra = new Dijkstra(graph, start);
dijkstra.printResult();
for (end = 0; end length; end++) {
if (end == start) {
continue;
}
int len = dijkstra.getLength(end);
System.out.println(" Length(" + start + "-" + end + ") = "
+ ((len == INF) ? "Infinity" : len));
}
}
}
}
java经典算法题——猴子吃桃
public class Monkey
{
public static void main(String[] args)
{
int sum=0,remain=1;
//每天吃剩的桃子加一个正好是前一天桃子的一半，每天桃子的总数就是前一天剩下桃子的数量
for(int day=9;day=1;day--)
{
sum=(remain+1)*2;
remain=sum;
System.out.println("第"+day+"天还剩"+remain+"个桃子");
}
System.out.println(sum);
}
}
java算法设计问题（贪心算法）
第一、你说的那个东西不叫框架
第二、你用的算法不是多路合并
第三、题目不是让你合并、是让你找出最优解
解答，我晕这题目有啥解答的啊，你不是自己编的吧，假如合并两个有序序列只要m+n-1次比较，那么不单单这两个序列各自有序，同时其中一个序列任意元素大于另外一个序列所有元素
那么答案就是按照k的序号从前想后依次合并啊
关于java算法题吃菜问题和java算法工程师的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。