算法分析习题集 Java版

目录

4.n元素幂集

5.插入排序

6.俄式乘法

7.AVL树

8.数学三角形

9.最长上升子序

10.投资分配

11.活动安排——贪心算法

12.一般背包问题——贪心算法

4.n元素幂集

Java代码：

思路：减一法 ——>利用递推式：p(n) = p(n-1) + IPN (IPN为前项和后项的一种关系)

import java.util.ArrayList;

public class PowerSet {
    public static void main(String[] args) {
        String[] a = { "1", "2","3", "4" };
        ArrayList<String> pn = getSet(a); //
        System.out.println("Set size is = " + pn.size());
        for (int i = 0; i < a.length; i++) {
            String string = a[i];
        }
        System.out.println(pn.toString());
    }

    public static ArrayList<String> getSet(String[] a) {
        ArrayList<String> pn = new ArrayList<String>(); // creat a list to save set
        pn.add("");
        for (int i = 0; i < a.length; i++) {
            pn.addAll(IPN(pn, a[i])); // 递推式：p(n) = p(n-1) + IPN p(0) = {"","1"}; p(1) = p{"","1","2","1,2"}...
            // System.out.println("pn.addAll = " + pn.toString());
            // System.out.println("--------------------");
        }
        return pn;
    }

    public static ArrayList<String> IPN(ArrayList<String> pn, String i) {
        ArrayList<String> tmp = new ArrayList<String>();
        for (int k = 0; k < pn.size(); k++) {
            // System.out.println("pn.get[k] = " + pn.get(k));
            tmp.add(pn.get(k) + i); // 临时list存储元素
            // System.out.printf("tmp.get(%d) = %s
", k, tmp.get(k));
        }
        return tmp;
    }
}

运行结果：

Set size is = 16
[, 1, 2, 12, 3, 13, 23, 123, 4, 14, 24, 124, 34, 134, 234, 1234]

C代码

思路：递归法——>树的先序遍历

//递归树的叶子节点
int P(char *str, int n,int index){
    static char tmp[10];
    int case1 = 0, case2 = 0;
    
    if(n==-1){
        //递归结束条件,输出叶子节点
        tmp[index] = ''; //最后的变换为0，起是否选择n作用
        printf("%s	", tmp);
        return 1;  //数量+1
    }
    else{
        tmp[index] = str[strlen(str)-1 - n]; //默认选取index,反转一下正序，也可以只是n 
        case1 = P(str, n - 1, index + 1); //继续选，所以index+1
        case2 = P(str, n - 1, index); //不选，由于默认选取了，需要覆盖，所以不加1
    }
    //printf("
");
    return case1 + case2;  //数量总和
}

int main() {
    char tmp[10];
    int cnt;
    printf("输入字符串: ");
    scanf("%s", tmp);
    cnt = P(tmp, strlen(tmp)-1, 0);
    printf("共有%d情况", cnt);
    return 0;
}

运行结果：

输入字符串: abc
abc ab ac a bc b c 共有8情况

5.插入排序

代码：

import java.util.Arrays;

/*
 * 应用插入排序对序列2,6,1,4,5,3,2进行排序
 */

public class InsertSort {
    public static void main(String[] args) {
        int[] a = { 2, 6, 1, 4, 5, 3, 2 };
        Insertsort(a);
        System.out.println(Arrays.toString(a));
    }

    public static void Insertsort(int[] a) {
        int i, j;
        for (i = 1; i < a.length; i++) {
            int cur = a[i]; // 待比较值
            for (j = i - 1; j >= 0 && a[j] > cur; j--) {
                a[j + 1] = a[j];
            }
            a[j + 1] = cur;

        }
    }
}

运行结果：

[1, 2, 2, 3, 4, 5, 6]

6.俄式乘法

代码：

import java.util.Scanner;

public class RussianMultiplication {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入两个数字（回车符间隔）");
        int n = sc.nextInt();
        int m = sc.nextInt();
        sc.close();
        int res = Rmult(n, m);
        System.out.printf("%d * %d == %d", n, m, res);
    }

    public static int Rmult(int n, int m) {
        int sum = 0;
        while (n != 0) {
            if (n % 2 != 0) {
                n--; // 奇数情况
                sum += m;
            } else {
                n >>= 1;
                m <<= 1;
            }
        }
        return sum;
    }
}

运行结果：

请输入两个数字（回车符间隔）
50
65
50 * 65 == 3250

7.AVL树

public class AVLTree<Key extends Comparable<? super Key>, Value> {
    private class Node {
        Key key;// 键，相当于词典里的单词
        Value value;// 值，相当于词典里的单词解释
        int height;// 结点的高度
        Node left;
        Node right;

        public Node(Key key, Value value) {
            this.key = key;
            this.value = value;
            this.left = null;
            this.right = null;
            int height = 1;
        }
    }

    private Node root; // 根节点

    public AVLTree() {
        root = null;
    }

    // 获取节点高度
    private int height(Node node) {
        if (node != null) {
            return node.height;
        }
        return 0;
    }

    // 获取根高度
    public int height() {
        return height(root);
    }

    private int max(int a, int b) {
        return a > b ? a : b; // 获取较大值
    }

    // 替换节点？
    private void replaceNode(Node src, Node tar) {
        tar.key = src.key;
        tar.value = src.value;
    }

    // 遍历----------------------------------------------------
    // 先序遍历
    private void preOrder(Node node) {
        if (node != null) {
            System.out.print(node.key + " ");
            preOrder(node.left);
            preOrder(node.right);
        }
    }

    public void preOrder() {
        preOrder(root);
    }

    // 中序遍历
    private void inOrder(Node node) {
        if (node != null) {
            inOrder(node.left);
            System.out.print(node.key + " ");
            inOrder(node.right);
        }
    }

    public void InOrder() {
        inOrder(root);
    }

    // 后序遍历
    private void postOrder(Node node) {
        if (node != null) {
            postOrder(node.left);
            postOrder(node.right);
            System.out.print(node.key + " ");
        }
    }

    public void postOrder() {
        postOrder(root);
    }
    // -------------------------------------------------------

    // 查找key位置
    private Node search(Node node, Key key) {
        if (node == null) {
            return null;
        } else if (key.compareTo(node.key) == 0) {
            return node;
        } else if (key.compareTo(node.key) < 0) {
            return search(node.left, key); // 左子树
        } else {
            // key.compareTo(node.key) > 0
            return search(node.right, key); // 右子树
        }
    }

    public Node Search(Key key) {
        return search(root, key);
    }

    // 返回最小左节点
    private Node minNode(Node node) {
        if (node == null) {
            return null;
        } else if (node.left == null) {
            return node;
        } else {
            return minNode(node.left);
        }
    }

    public Node minNode() {
        return minNode(root);
    }

    // 返回最大右节点
    private Node maxNode(Node node) {
        if (node == null) {
            return null;
        } else if (node.right == null) {
            return node;
        } else {
            return maxNode(node.right);
        }
    }

    public Node maxNode() {
        return maxNode(root);
    }

    // 旋转----------------------------------------------------
    public Node leftLeftRotation(Node k1) {
        /*
         * LL单旋转 --- 右旋转
         */
        Node k2 = k1.left; // 失衡点左子树是k2
        k1.left = k2.right; // k2的右子树变为 失衡点k1的左子树
        k2.right = k1; // k2的右子树变为k1
        // 重新计算各子树的高度
        k1.height = max(height(k1.left), height(k1.right)) + 1;
        k2.height = max(height(k2.left), height(k2.right)) + 1;
        return k2; // 返回平衡后的点k2
    }

    public Node rightRightRotation(Node k1) {
        /*
         * RR单旋转 --- 左旋转
         */
        Node k2 = k1.right; // 失衡点左子树是k2
        k1.right = k2.left; // k2的右子树变为 失衡点k1的左子树
        k2.left = k1; // k2的右子树变为k1
        // 重新计算各子树的高度
        k1.height = max(height(k1.left), height(k1.right)) + 1;
        k2.height = max(height(k2.left), height(k2.right)) + 1;
        return k2; // 返回平衡后的点k2
    }

    public Node leftRightRotation(Node k1) {
        /*
         * LR双旋转
         */
        k1.left = rightRightRotation(k1.left); // 左旋
        return leftLeftRotation(k1); // 右旋
    }

    public Node rightLeftRotation(Node k1) {
        /*
         * RL双旋转
         */
        k1.right = leftLeftRotation(k1.right); // 左旋
        return rightRightRotation(k1); // 右旋
    }
    // -----------------------------------------------------

    // 插入并调整为平衡树
    private Node insert(Node node, Key key, Value value) {
        if (node == null)
            return new Node(key, value);

        if (key.compareTo(node.key) == 0) {// key相同，更新节点
            node.value = value;
        } else if (key.compareTo(node.key) < 0) {
            node.left = insert(node.left, key, value); // 递归找左子树
            if (height(node.left) - height(node.right) == 2) {
                // 不平衡，需要进行调整
                if (key.compareTo(node.left.key) < 0) {
                    node = leftLeftRotation(node); // 比节点的左key小，LL情况
                } else {
                    node = leftRightRotation(node); // 比节点的右key小,RR情况
                }
            }
        } else {
            node.right = insert(node.right, key, value); // 递归找右子树
            if (height(node.right) - height(node.left) == 2) {
                if (key.compareTo(node.right.key) > 0) {
                    node = rightRightRotation(node); // 比节点的右key大，RR情况
                } else {
                    node = rightLeftRotation(node);
                }
            }
        }
        node.height = max(height(node.right), height(node.left)) + 1; // 调整高度
        return node; // 返回根节点
    }

    public void insert(Key key, Value value) {
        this.root = insert(this.root, key, value);
    }

    // 删除
    public Node remove(Node node, Node target) {
        /**
         * @param node 当前子树根节点
         * @parma target 要删除的节点 return 删除后的新的子树根
         */
        if (node == null || target == null)
            return node; // 空情况
        if (target.key.compareTo(node.key) < 0) {
            node.left = remove(node.left, target); // 左子树继续找
            if (Math.abs(height(node.right) - height(node.left)) == 2) { // 失衡
                if (height(node.right.left) < height(node.right.right)) {
                    node = rightRightRotation(node); // 左旋
                } else {
                    node = leftLeftRotation(node); // 右旋
                }
            }
        } else if (target.key.compareTo(node.key) > 0) {
            node.right = remove(node.right, target); // 右子树继续找
            if (Math.abs(height(node.left) - height(node.right)) == 2) {// 失衡
                if (height(node.left.right) < height(node.left.left)) {
                    node = leftLeftRotation(node); // 右旋
                } else {
                    node = rightRightRotation(node); // 左旋
                }
            }
        } else {// node.key == target.key
            if (node.left == null) {
                return node.right; // 左子树null，那么删除后右子树变为根
            } else if (node.right == null) {
                return node.left; // 右子树null，那么删除后左子树变为根
            } else {
                // 左右子树 均存在
                if (height(node.left) > height(node.right)) {
                    // 左子树 深于 右子树
                    Node predecessor = maxNode(node.left);
                    replaceNode(predecessor, node); // 替换
                    node.left = remove(node.left, predecessor);
                } else {// 如果右子树比左子树深(一样深的话无所谓了)
                    Node successor = minNode(node.right);// 找node的后继结点successor
                    replaceNode(successor, node);// successor替换node
                    node.right = remove(node.right, successor);// 再把原来的successor删掉
                }

            }

        }
        return node;
    }

    public void remove(Key key) {
        Node z;
        if ((z = search(root, key)) != null) // 找到key位置
            root = remove(root, z);
    }

    // 销毁AVL树----------------------------------------------
    private void destroy(Node node) {
        if (node == null)
            return;
        if (node.left != null)
            destroy(node.left); // 摧毁左子树
        if (node.right != null)
            destroy(node.right); // 摧毁右子树
        node = null;
    }

    public void destroy() {
        destroy(root);
        System.out.println("销毁完毕");
    }
    // ---------------------------------------------------------

    // 递归输出AVL树的信息------------------------------------------------
    private void print(Node tree, Key key, String pos) {
        if (tree != null) {
            if (pos.equals("")) // tree是根节点
                System.out.printf("%2d is root
", tree.key);
            else
                System.out.printf("%2d is %2d's %6s child
", tree.key, key, pos);
            print(tree.left, tree.key, "left"); // 左子树
            print(tree.right, tree.key, "right"); // 右子树
        }
    }

    public void print() {
        if (root != null)
            print(root, root.key, "");
    }
    // -----------------------------------------------------------

    private static int arr[] = { 3, 2, 1, 4, 5, 6, 7, 16, 15, };

    public static void main(String[] args) {
        int i;
        AVLTree<Integer, Integer> tree = new AVLTree<>();

        System.out.printf("*******依次添加: ");
        for (i = 0; i < arr.length; i++) {
            System.out.printf("%d ", arr[i]);
            tree.insert(arr[i], arr[i]);
        }

        System.out.println("
前序遍历");
        tree.preOrder();

        System.out.println("
中序遍历");
        tree.InOrder();

        System.out.println("
后序遍历");
        tree.postOrder();

        System.out.println("
高度 : " + tree.height());
        System.out.println("最小值: " + tree.minNode().key);
        System.out.println("最大值: " + tree.maxNode().key);
        System.out.println("
树的详细信息：");
        tree.print();

        i = 5;
        System.out.printf("
删除节点 ： %d", i);
        tree.remove(i);

        System.out.println("树的高度 : " + tree.height());
        System.out.print("中序遍历: ");
        tree.InOrder();
        System.out.println("
树的详细信息: ");
        tree.print();

        tree.destroy(); // 销毁树
    }
}

运行结果：

*******依次添加: 3 2 1 4 5 6 7 16 15
前序遍历
5 3 2 1 4 7 6 16 15
中序遍历
1 2 3 4 5 6 7 15 16
后序遍历
1 2 4 3 6 15 16 7 5
高度 : 3
最小值: 1
最大值: 16

树的详细信息：
5 is root
3 is 5's left child
2 is 3's left child
1 is 2's left child
4 is 3's right child
7 is 5's right child
6 is 7's left child
16 is 7's right child
15 is 16's left child

删除节点 ： 5树的高度 : 3
中序遍历: 1 2 3 4 6 7 15 16
树的详细信息:
6 is root
3 is 6's left child
2 is 3's left child
1 is 2's left child
4 is 3's right child
7 is 6's right child
16 is 7's right child
15 is 16's left child
销毁完毕

8.数学三角形

题目：

 代码：

public class MathematicalTriangle {

    public static void main(String[] args) {
        int[][] a = { { 1 }, { 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 , 10} };

        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.printf("%4d", a[i][j]);
            }
            System.out.println();
        }
        System.out.println();
        int res = minimunTotal(a);

        System.out.println("min path : " + res);
    }

    public static int minimunTotal(int[][] triangle) {
        int row = triangle.length; // 行
        int column = triangle[row - 1].length; // 列

        int[][] dp = new int[row][column]; // 辅助矩阵
        dp[0][0] = triangle[0][0];

        for (int i = 1; i < row; i++) {
            // 每一行元素进行推导
            for (int j = 0; j <= i; j++) {
                if (j == 0) {
                    // 最左端处理
                    dp[i][j] = dp[i - 1][j] + triangle[i][j];
                } else if (j == i) {
                    // 最右端处理 没有上面
                    dp[i][j] = dp[i - 1][j - 1] + triangle[i][j];
                } else {
                    dp[i][j] = Math.min(dp[i - 1][j - 1], dp[i - 1][j]) + triangle[i][j];
                }
            }
        }

        int res = Integer.MAX_VALUE;
        for (int i = 0; i < column; i++) {
            res = Math.min(res, dp[row - 1][i]);
        }

        for (int i = 0; i < dp.length; i++) {
            for (int j = 0; j < dp[i].length; j++) {
                System.out.printf("%4d", dp[i][j]);
            }
            System.out.println();
        }
        return res;
    }
}

运行结果：

9.最长上升子序

题目：

代码：

import java.util.Arrays;

public class LongestSubsequence {
    public static void main(String[] args) {
        int[] nums = { 5, 8, 9, 2, 3, 1, 7, 4, 6 };
        int n = Solution.lengthOfLIS(nums);
        System.out.println("
最长子序长度：" + n);
    }
}

class Solution {

    public static int lengthOfLIS(int[] nums) {
        int len = nums.length, max = 0;
        int[] dp = new int[len];
        Arrays.fill(dp, 1); // 初始化为1

        for (int i = 1; i < len; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i] && dp[i] < dp[j] + 1) { // 前面有比我小的吗？
                    dp[i] = dp[j] + 1; // 有的，那就取当前比较大的状态
                }
            }
            if (max < dp[i]) {
                max = dp[i];
            }
        }

        int[] arr = new int[max];
        System.out.print("最长子序：");
        for (int i = nums.length - 1; i >= 0; i--) {
            if (dp[i] == max) {
                arr[max - 1] = nums[i];
                max--;
            }
        }
        for (int i : arr) {
            System.out.print(i + " ");
        }

        int res = 0;
        for (int i = 0; i < len; i++) {
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

运行结果：

最长子序：2 3 4 6
最长子序长度：4

10.投资分配

题目:

 代码：

public class ResourceAllocation {

    public static void main(String[] args) {
        int[][] f = { { 0, 0, 0, 0, 0 }, // 没有第0个项目
                { 0, 15, 28, 40, 51 }, { 0, 13, 29, 43, 55 }, { 0, 11, 30, 45, 58 }, };

        System.out.println("最大利润:" + SolutionInvest.investMax(f));
    }
}

class SolutionInvest {
    static int M = 4 + 1; // 投资总数+1，4万元， 因为多了一列0向量
    static int N = 3 + 1; // 项目数+1，3项目， 因为多了一行0向量

    public static int investMax(int[][] f) {
        /*
         * 返回最大利润
         * 
         * @param f：投资矩阵
         */

        int[][] Fsum = new int[N][M]; // 前N个项目共投资M万元的最大收益
        int[][] aItem = new int[N][M]; // 共投资M万元时第N个项目的投资金额，用于追溯路径

        // 初始化表格的情况，即边界情况,具体情况看可表格
        for (int i = 0; i < M - 1; i++) {
            Fsum[1][i] = f[1][i];
            aItem[1][i] = i;
        }

        // 第 k 个项目的投资
        for (int k = 2; k <= N - 1; k++) {
            // 第一行一列是0，第一行即只投资一个项目的情况已经初始化，故从2开始
            for (int m = 1; m <= M - 1; m++) { // M是投资数+1，所以此处循环到M-1
                // 前 K 个项目共分配 m 万元，计算出当投资m万元时候的最好方案
                int max = -1, temp = 0; // 初始化利润为-1
                for (int a = 0; a <= m; a++) {
                    // 第 k 个项目分配 a 万元， 计算对比当投资额为m万元时候，第K个项目的最好投资数
                    if (f[k][a] + Fsum[k - 1][m - a] > max) {
                        // fk(x) = d 表示：x 万元投给第 k 个项目的效益为 d.
                        // 对比 f2(1)+F1(0), f2(0)+F1(1) 得出好的投资方案
                        max = f[k][a] + Fsum[k - 1][m - a];
                        temp = a; // 记录总投资为m万元时第k个项目的投资金额
                    }
                }
                Fsum[k][m] = max; // 前K个项目共投资m万元时候的最大收益
                aItem[k][m] = temp; // 记录投资m万元时候第k个项目的投资金额
            }
        }
        printArray(Fsum);
        printArray(aItem);
        printInfo(aItem); // 输出投资信息
        return Fsum[N - 1][M - 1];
    }

    private static void printInfo(int[][] aItem) {
        int index = M - 1;
        for (int k = N - 1; k > 0; k--) {
            System.out.println("第" + k + "个项目，投资" + aItem[k][index] + "万元");
            index -= aItem[k][index];
        }
    }

    private static void printArray(int[][] a) {
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.printf("%4d", a[i][j]);
            }
            System.out.println();
        }
        System.out.println();
    }
}

运行结果：

0 0 0 0 0
0 15 28 40 0
0 15 29 44 58
0 15 30 45 60

0 0 0 0 0
0 1 2 3 0
0 0 2 2 3
0 0 2 2 3

第3个项目，投资3万元
第2个项目，投资0万元
第1个项目，投资1万元
最大利润:60

代码（C语言版）：

#include<iostream>
#define N 4//项目数+1  多了一行0矩阵
#define M 5//投资总额+1 多了一列0矩阵

using namespace std;

//aItem[3][2]表示共投资2万元第3个项目的投资金额，用于追溯路径
double aItem[N][M] = {0};
//Fsum[3][2]表示前3个项目共投资2万元的最大收益
double Fsum[N][M] = { 0 };

double investMax(double f[N][M]){
    // 前一个项目的情况
    for (int i = 0; i <= M - 1;i++){
        Fsum[1][i] = f[1][i];
        aItem[1][i] = i;
    }
    // 第 k 个项目
    for (int k = 2; k <= N - 1;k++){
        // 前 k 个项目 共 分配 m 万元
        for (int m = 1; m <= M - 1; m++){
            double max = -1, temp = 0;
            // 第 k 个项目分配 a 万元
            for (int a = 0; a <= m; a++){
                if(f[k][a] + Fsum[k-1][m-a] > max){
                    max = f[k][a] + Fsum[k - 1][m - a];
                    temp = a;
                }
            }
            Fsum[k][m] = max; // 前 k 个项目共投资 m 万元的最大收益
            aItem[k][m] = temp; // 投资 m 万元第 k 个项目的投资金额
        }
    }
    return Fsum[N - 1][M - 1];
}

void printInfo(){
    int index = M - 1;
    for (int k = N - 1; k > 0;k--){
        cout << "第" << k << "个项目，投资" << aItem[k][index] << "万元"<<endl;
        index -= aItem[k][index]; // 剩余钱数
    }
}

int main() {

    double f[N][M] = {//f[1][2]表示投第1个项目2万元所产生的效益
        {0, 0, 0, 0, 0},//没有第0个项目
        {0,15,28,40,51},
        {0, 13, 29,43,55},
        {0, 11,30,45,58},
    };
    cout << M-1 <<"万元投资"<<N-1<<"项目最大收益为：" << investMax(f) << endl;
    printInfo();

    printf("
");
    for (int i = 0; i < N;i++){
        for (int j = 0; j < M;j++)
            printf("%g 	", aItem[i][j]);
        printf("
");
    }

    printf("
");
    for (int i = 0; i < N;i++){
        for (int j = 0; j < M;j++)
            printf("%g 	", Fsum[i][j]);
        printf("
");
    }
        return 0;
}

运行结果：

4万元投资3项目最大收益为：60
第3个项目，投资3万元
第2个项目，投资0万元
第1个项目，投资1万元

0 0 0 0 0
0 1 2 3 4
0 0 2 2 3
0 0 2 2 3

0 0 0 0 0
0 15 28 40 51
0 15 29 44 58
0 15 30 45 60

11.活动安排——贪心算法

public class ActivityArrangement {
    public static void main(String[] args) {
        int[] s = { 0, 1, 3, 0, 5, 3, 5, 6, 8, 8, 2, 12 };
        int[] f = { 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };
        int n = 11;
        boolean[] a = new boolean[12];
        int count = Greedy.ActiveManage(s, f, a, n);
        System.out.println("可安排的活动总数:" + count);
        System.out.print("选择活动如下：");
        for (int i = 0; i < a.length; i++) {
            if (a[i] == true) {
                System.out.print(i + " ");
            }
        }
    }
}

class Greedy {
    public static int ActiveManage(int[] s, int[] f, boolean a[], int n) {
        /**
         * 贪心策略：取当前活动集合中结束时间最早的相容活动，这样可以为未安排的活动留下心网能多的时间，
         * 也就是说，这种贪心选择的目的是使剩余时间段极大化，以便安排尽可能多的相容活动。
         * 
         * @param s  : 活动起始时间
         * @param f: 活动结束时间
         * @param a: 是否选择活动
         * @param n  : 活动总数
         * @return count: 安排的活动数
         */
        a[1] = true; // 默认选择第一个活动
        int j = 1, count = 1; // count 记录选取到的活动总数
        for (int i = 2; i <= n; i++) { // 候选集合C
            if (s[i] >= f[j]) { // 选择函数(贪心策略)
                a[i] = true; // 解集合S
                j = i;
                count++;
            } else {
                a[i] = false;
            }
        }
        return count;
    }
}

运行结果：

可安排的活动总数:4
选择活动如下：1 4 8 11

12.一般背包问题——贪心算法

public class GeneralBackpack {
    public static void main(String[] args) {
        float[] w = { 0, 10, 30, 20 };
        float[] v = { 0, 50, 120, 60 };
        float[] x = new float[4];
        float C = 50;
        int n = 4;
        float total = bag.Knapsack(w, v, x, C, n);
        System.out.println("总价值:" + total);
        for (int i = 1; i < x.length; i++) {
            System.out.printf("第%d个物品数量为:%f,价值为%f
", i, x[i], x[i] * v[i]);
        }
    }
}

class bag {
    public static float Knapsack(float[] w, float[] v, float[] x, float C, int n) {
        /**
         * n个物品已经按照V/W 由大到小 贪心策略：考虑价值增长和容量消耗二者的综合效果的方法，即每次选择价值与重量比u:/w
         * 
         * @param w: 重量
         * @param v: 价值
         * @param x: 解
         * @param C: 背包重量
         * @param n: 物品数量
         * @return total 总价值
         */
        for (int i = 0; i < n; i++) {
            x[i] = 0; // 初始化解向量
        }
        int i = 1; // 由于从1开始 所以w和v前面都要加0
        float total = 0; // 总重量
        while (w[i] < C) { // 可行函数feasible / 解决函数solution
            x[i] = 1;
            total = total + v[i]; // 解集合 —— 总价值
            C = C - w[i]; // 剩余背包重量
            i++; // 下一个物品
        }
        x[i] = C / w[i]; // 使用完剩余的一点空间
        total = total + v[i] * x[i];
        return total;
    }
}

运行结果：

总价值:200.0
第1个物品数量为:1.000000,价值为50.000000
第2个物品数量为:1.000000,价值为120.000000
第3个物品数量为:0.500000,价值为30.000000