java動態規劃演算法
⑴ java里如何實現動態演算法如把一個算式((A*B)>0 || (C+D)=0)解析成JAVA代碼里的邏輯，其中ABCD為變數。
這個是這樣的，|| 是短路或操作， 就是說前面一個表達式 為假時才執行後面一個表達式， 即
當 （A*B） >0 時 不執行 (C+D) == 0 判斷操作（其實是==，單個等號是賦值）
當 （A*B） <= 0 時 執行（C+D）==0判斷
你問出這個問題只能說明你的大學教授水平比較次。。。。。
⑵ java的動態規劃法和貪心演算法求解
分太少了。。
⑶ 演算法分析中動態規劃的四個基本步驟
1、描述優解的結構特徵。
2、遞歸地定義一個最優解的值。
3、自底向上計算一個最優解的值。
4、從已計算的信息中構造一個最優解。
⑷ ~~求解~~用動態規劃演算法求兩數組各元素間差的最小值，JAVA代碼或方法思路
import java.util.Arrays;
public class Test {
public static void getCha(int [] a,int []b){
int min =Integer.MAX_VALUE;
int sss=0;
int kkk = 0;
int c = 0;
int d = 0;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < b.length; j++) {
int temp = Math.abs(a[i]-b[j]);
if(temp<min){
min = temp;
sss = a[i];
kkk = b[j];
c=i;
d=j;
}
}
}
System.out.println("最大差距："+min+"數組A["+c+"]"+sss+"數組B["+d+"]"+kkk);
}
public static void main(String[] args) {
int []a = new int[8];
int []b = new int[12];
for (int i = 0; i < a.length; i++) {
a[i] = (int)( Math.random()*100);
}
System.out.println(Arrays.toString(a));;
for (int i = 0; i < b.length; i++) {
b[i] = (int) (Math.random()*100);
}
System.out.println(Arrays.toString(b));
getCha(a,b);
}
}
⑸ JAVA里如何實現動態演算法
如果只是簡單的加減乘除，採用遞歸方式，按照運算符優先順序計算，最後得到結果如果復雜一點，可以採用動態編譯，你寫的字元串算式，就變成java代碼，最後採用反射執行兩種方式。
⑹ java十大演算法
演算法一：快速排序演算法
快速排序是由東尼·霍爾所發展的一種排序演算法。在平均狀況下，排序 n 個項目要Ο(n log n)次比較。在最壞狀況下則需要Ο(n2)次比較，但這種狀況並不常見。事實上，快速排序通常明顯比其他Ο(n log n) 演算法更快，因為它的內部循環（inner loop）可以在大部分的架構上很有效率地被實現出來。
快速排序使用分治法（Divide and conquer）策略來把一個串列（list）分為兩個子串列（sub-lists）。
演算法步驟：
1 從數列中挑出一個元素，稱為 "基準"（pivot），
2 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分區退出之後，該基準就處於數列的中間位置。這個稱為分區（partition）操作。
3 遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。
遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，但是這個演算法總會退出，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最後的位置去。
演算法二：堆排序演算法
堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序演算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。
堆排序的平均時間復雜度為Ο(nlogn) 。
演算法步驟：
創建一個堆H[0..n-1]
把堆首（最大值）和堆尾互換
3. 把堆的尺寸縮小1，並調用shift_down(0),目的是把新的數組頂端數據調整到相應位置
4. 重復步驟2，直到堆的尺寸為1
演算法三：歸並排序
歸並排序（Merge sort，台灣譯作：合並排序）是建立在歸並操作上的一種有效的排序演算法。該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。
演算法步驟：
1. 申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合並後的序列
2. 設定兩個指針，最初位置分別為兩個已經排序序列的起始位置
3. 比較兩個指針所指向的元素，選擇相對小的元素放入到合並空間，並移動指針到下一位置
4. 重復步驟3直到某一指針達到序列尾
5. 將另一序列剩下的所有元素
⑺ 那，就是之前那個演算法「找2個串中最長連續相同子串」，在java中用動態規劃演算法如何實現呢
沒讀懂
⑻ 常用的演算法在java里邊怎麼做，例
（一） 問題描述
給定由n個整數（可能為負整數）組成的序列a1，a2，a3，···，an，求該序列的子段和的最大值。當所有整數均為負整數是定義其最大子段和為0，一次定義，所求的最優質值為：max{0、max子段和}。
（二） 演算法描述
動態規劃法的基本思想：
動態規劃演算法通常用於求解具有某種最優性質的問題。在這類問題中，可能會有許多可行解。每一個解都對應於一個值，我們希望找到具有最優值的解。
演算法設計：
#include "stdafx.h"
int MaxSum(int a[],int n,int &Start,int&End){
intsum=0;
int*b,t;
b=newint[n+1];
b[0]=0;
for(inti=1;i<=n;i++){
if(b[i-1]>0){
b[i]=b[i-1]+a[i];
}
else {
b[i]=a[i];t=i;
}
if(b[i]>sum){
sum=b[i];
Start=t;
End=i;
}
}
delete[]b;
returnsum;
}
int main(int argc, char* argv[])
{
inta[7]={0,-2,11,-4,13,-5,-2},sum,Start,End,i;
sum=MaxSum(a,6,Start,End);
for(i=Start;i<=End;i++){
printf("%d ",a[i]);
}
printf("\n%d\n",sum);
getchar();
getchar();
return0;
⑼ java動態規劃 計算數n由k個數相加而成的情況數
publicclassMyClass{
publicstaticvoidmain(String[]args){
System.out.println(">>>resultcount:"+method(6,3));
}
publicstaticintmethod(intn,intk){
List<List<Integer>>list=newArrayList<>();
for(inti=0;i<k;i++){
if(i==0){
for(intj=1;j<n;j++){
List<Integer>li=newArrayList<>();
li.add(j);
list.add(li);
}
continue;
}
List<List<Integer>>listNew=newArrayList<>();
for(List<Integer>integers:list){
for(intj=integers.get(integers.size()-1);j<n;j++){
List<Integer>li=newArrayList<>();
li.addAll(integers);
li.add(j);
listNew.add(li);
if(i+1==k){
intres=0;
for(Integerinteger:li){
res+=integer;
}
if(res!=n){
listNew.remove(li);
}
}
}
}
list.clear();
list.addAll(listNew);
}
for(List<Integer>integers:list){
for(Integerinteger:integers){
System.out.print(integer+" ");
}
System.out.println();
}
returnlist.size();
}
}