Java数据结构与算法----动态规划（背包篇）

news2025/2/28 4:28:05

1. 0/1背包

1.1.算法思路

0/1背包是动态规划、背包问题中最经典的问题啦！它主要的问题是：

给定n种物品、这n种物品的重量分别是W_{i}，价值分别是V_{i} ，而你有一个容量为C的背包，请问如何求出所能拿的最大价值呢？

对于动态规划，我们先需要找到一条推导公式，然后确定边界：

我们设dp[i][j]为一个背包，表示前 i 个物品装入容器为 j 的背包中可以获得的最大价值。

我们可以推导出： dp[i] [j] = max(dp[i-1] [j] , dp[i-1] [j - W_{i} ] + V_{i} ) 也就是说，当前的dp值由装和不装入第i个物品来决定的。不装入第i个是：dp[i-1] [j] ，装入的话 j 要减去这个物品的重量也就是：

  dp[i-1] [j - W_{i} ] + V_{i} 。

1.2.例题与代码

01背包问题

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。

第 i 件物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式

第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。

接下来有 N 行，每行两个整数 vi , wi 用空格隔开，分别表示第 i 件物品的体积和价值。

输出格式

输出一个整数，表示最大价值。

数据范围

0<N,V≤1000
0<vi,wi≤1000

输入样例

4 5
1 2
2 4
3 4
4 5

输出样例：

8

 题解：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * @Author: stukk
 * @Description: TODO
 * @DateTime: 2023-04-12 0:19
 **/
public class Main {
    private static BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
    private static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
    public static void main(String[] args) {
        int n,v;//物品数量、容积
        int value[] = new int[1001];
        int weight[] = new int[1001];
        Scanner cin = new Scanner(System.in);
        n = cin.nextInt();
        v = cin.nextInt();
        int dp[][] = new int[n+1][v+1];
        for(int i = 1;i<=n;i++) {
            weight[i] = cin.nextInt();
            value[i] = cin.nextInt();
        }
        //输入完毕。
        for(int i = 1;i<=n;i++) {
            for(int j = 0;j<=v;j++){
                if(j < weight[i]){
                    dp[i][j] = dp[i-1][j];
                }
                else{
                    dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-weight[i]] + value[i]);
                }
            }
        }
        System.out.println(dp[n][v]);
    }
}

优化：

其实可以用dp[] 来替代 dp[][]以节省空间，因为i只跟上一行有关系，跟更前面的没关系，所以用新的一行覆盖上一行就ok了。

import java.util.*;
import java.math.*;
public class Main {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int n,v;//物品数量、容积
		int value[] = new int[10001];
		int weight[] = new int[10001];
		int dp[] = new int[10001];
		Scanner cin = new Scanner(System.in);
		n = cin.nextInt();
		v = cin.nextInt();
		for(int i = 1;i<=n;i++) {
			weight[i] = cin.nextInt();
			value[i] = cin.nextInt();
		}
		//输入完毕。
		for(int i = 1;i<=n;i++) {
			for(int j =v;j>=weight[i];j--) {
				dp[j] = Math.max(dp[j],(dp[j-weight[i]]+value[i]));
			}
		}
		System.out.println(dp[v]);
	}
}

2.完全背包

2.1.算法思路

完全背包和0/1背包只有一个区别，那就是0/1背包的物品数量只有1，只可以被装1次，而完全背包的物品数量无数，可以装多次。

在代码上，我们只需要将0/1背包的j循环换一下方向就行了：

2.2.例题与题解

完全背包问题

有 N种物品和一个容量是 V 的背包，每种物品都有无限件可用。

第 i种物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式

第一行两个整数，N，V 用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i种物品的体积和价值。

输出格式

输出一个整数，表示最大价值。

数据范围

0<N,V≤1000
0<vi,wi≤1000

输入样例

4 5
1 2
2 4
3 4
4 5

输出样例：

10

题解：

import java.util.Scanner;
/**
 * @Author: stukk
 * @Description: TODO
 * @DateTime: 2023-04-12 0:40
 **/
public class Main {
    public static void main(String[] args) {
        Scanner cin  =new Scanner(System.in);
        int n = cin.nextInt();
        int v = cin.nextInt();
        int weight[] = new int[n+1];
        int value[] = new int[n+1];
        int dp[] = new int[v+1];
        for(int i = 1;i <= n;i++){
            weight[i] = cin.nextInt();
            value[i] = cin.nextInt();
        }
        for(int i = 1;i<=n;i++){
            for(int j = weight[i]; j<=v;j++){
                dp[j] = Math.max(dp[j],dp[j-weight[i]] + value[i]);
            }
        }
        System.out.println(dp[v]);
    }
}

3.多重背包

3.1.算法思想

多重背包和完全背包、0/1背包只有一点区别，那就是多重背包设置了物品的数量了，（完全背包的物品有无数个，0/1背包的有一个）因此，我们需要在0/1背包的基础上加上数量的循环判断装与不装。而且它存在优化，我们在后面的优化会说到。

3.2.例题与题解

多重背包问题 I

有 N种物品和一个容量是 V 的背包。

第 i种物品最多有 si件，每件体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。

输入格式

第一行两个整数，N，V 用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行三个整数 vi,wi,si 用空格隔开，分别表示第 i 种物品的体积、价值和数量。

输出格式

输出一个整数，表示最大价值。

数据范围

0<N,V≤100
0<vi,wi,si≤100

输入样例

4 5
1 2 3
2 4 1
3 4 3
4 5 2

输出样例：

10

这个题的数量级只有100，不需要优化

import java.util.Scanner;

/**
 * @Author: stukk
 * @Description: TODO
 * @DateTime: 2023-04-12 0:54
 **/
public class Main {
    public static void main(String[] args) {
        Scanner cin  =new Scanner(System.in);
        int n = cin.nextInt();
        int v = cin.nextInt();
        int weight[] = new int[n+1];
        int value[] = new int[n+1];
        int count[] = new int[n+1];
        int dp[] = new int[v+1];
        for(int i = 1;i<=n;i++){
            weight[i] = cin.nextInt();
            value[i] = cin.nextInt();
            count[i] = cin.nextInt();
        }
        for(int i = 1;i<=n;i++){
            for(int j = v;j>=0;j--){
                for(int k = 0;k<=count[i] && j >= k*weight[i] ;k++){
                    dp[j] = Math.max(dp[j],dp[j - k*weight[i]] + k*value[i]);
                }
            }
        }
        System.out.println(dp[v]);
    }
}

优化：

对于多重背包，上面的做法是三重循环，复杂度肯定太高了啊，我们尝试把他变成0/1背包，怎么变成0/1背包呢？ 我们看：dp[j] = Math.max(dp[j],dp[j - k*weight[i]] + k*value[i]);这里的公式贼像0/1背包啊，我们尝试把count个物品用二进制表示：

假设：8个物品：二进制表示为 1000 ，对于装这个物品的使用情况会有：1 、2、3、4、5、6、7、8这8种情况，其实这些数字 可以由1  2  4 这三个数字组合成，对于n可以被分解成1,2,4,…,2^(k-1),n-2^k+1。然后把他们保存起来：进行0/1背包计算最大值就ok!

import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;

/**
 * @Author: stukk
 * @Description: TODO
 * @DateTime: 2023-04-12 1:14
 **/
public class Main {
    private static class stu{
        int weight;
        int value;

        public stu(int weight, int value) {
            this.weight = weight;
            this.value = value;
        }
    }
    public static void main(String[] args) {
        Scanner cin  =new Scanner(System.in);
        int n = cin.nextInt();
        int v = cin.nextInt();
        int dp[] = new int[v+1];
        List<stu> list = new LinkedList<>();
        for(int i = 1;i<=n;i++) {
            int weight = cin.nextInt();
            int value = cin.nextInt();
            int count = cin.nextInt();
            for(int j = 1;j <= count;j*=2){
                list.add(new stu(j*weight,j*value));
                count -= j;
            }
            if(count > 0){
                list.add(new stu(count*weight,count*value));
            }
        }
        for(stu s : list){
            for(int j = v;j>=s.weight;j--){
                dp[j] = Math.max(dp[j],dp[j-s.weight] + s.value);
            }
        }
        System.out.println(dp[v]);
    }
}

4.混合背包

4.1.算法思想

混合背包，所谓混合，就是包含了0/1背包、完全背包和多重背包，我们可以直接使用多重背包的二进制优化进行写。把01背包看作是数量为1的多重别抱，完全背包看成是数量为无数的多重背包就好了。

4.2.例题与题解

混合背包问题

有 N 种物品和一个容量是 V 的背包。

物品一共有三类：

  • 第一类物品只能用1次（01背包）；
  • 第二类物品可以用无限次（完全背包）；
  • 第三类物品最多只能用 si 次（多重背包）；

每种体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。

输入格式

第一行两个整数，N，V ，用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行三个整数 vi,wi,si 用空格隔开，分别表示第 i 种物品的体积、价值和数量。

  • si=−1 表示第 i 种物品只能用1次；
  • si=0 表示第 i 种物品可以用无限次；
  • si>0 表示第 i 种物品可以使用 si 次；

输出格式

输出一个整数，表示最大价值。

数据范围

0< N,V ≤1000
0< vi,wi ≤1000
−1≤ si ≤1000

输入样例

4 5
1 2 -1
2 4 1
3 4 0
4 5 2

输出样例：

8
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;

/**
 * @Author: stukk
 * @Description: TODO
 * @DateTime: 2023-04-12 10:10
 **/
public class Main {
    private static class stu{
        int weight;
        int value;

        public stu(int weight, int value) {
            this.weight = weight;
            this.value = value;
        }
    }
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        int v = cin.nextInt();
        int dp[] = new int[v+1];
        List<stu> list = new LinkedList<>();
        for(int i = 1;i<=n;i++){
            int weight = cin.nextInt();
            int value = cin.nextInt();
            int s = cin.nextInt();
            if(s == -1){
                list.add(new stu(weight,value));
            }
            else if(s == 0){
                for(int j = 1;j*weight <= v;j*=2 ){
                    list.add(new stu(j*weight,j*value));
                }
            }
            else{
                for(int j = 1;j<=s && j*weight<=v;j*=2){
                    list.add(new stu(j*weight,j*value));
                    s -= j;
                }
                if(s > 0){
                    list.add(new stu(s*weight,s*value));
                }
            }
        }
        for(stu s : list){
            for(int j = v;j>=s.weight;j--){
                dp[j] = Math.max(dp[j],dp[j - s.weight] + s.value);
            }
        }
        System.out.println(dp[v]);
    }
}

5.二位费用背包

5.1.算法思想

二位费用背包其实就是在01背包的基础上再加上一个条件限制，比如在背包中加上体积、重量这两个限制，也就是变成二维了。我们需要把dp数组变成二维的，用来代表体积、重量的背包。

5.2.例题与题解

二维费用的背包问题

有 N 件物品和一个容量是 V 的背包，背包能承受的最大重量是 M。

每件物品只能用一次。体积是 vi，重量是 mi，价值是 wi。

求解将哪些物品装入背包，可使物品总体积不超过背包容量，总重量不超过背包可承受的最大重量，且价值总和最大。
输出最大价值。

输入格式

第一行三个整数，N,V,M，用空格隔开，分别表示物品件数、背包容积和背包可承受的最大重量。

接下来有 N 行，每行三个整数 vi,mi,wi，用空格隔开，分别表示第 i 件物品的体积、重量和价值。

输出格式

输出一个整数，表示最大价值。

数据范围

0<N≤1000
0<V,M≤100
0<vi,mi≤100
0<wi≤1000

输入样例

4 5 6
1 2 3
2 4 4
3 4 5
4 5 6

输出样例：

8

import java.util.Scanner;

/**
 * @Author: stukk
 * @Description: TODO
 * @DateTime: 2023-04-12 10:56
 **/
public class Main {

    public static void main(String[] args) {
        Scanner cin  =new Scanner(System.in);
        int n = cin.nextInt();
        int v = cin.nextInt();
        int m = cin.nextInt();
        int vi[] = new int[n+1];
        int weight[] = new int[n+1];
        int value[] = new int[n+1];

        for(int i = 1;i<=n;i++){
            vi[i] = cin.nextInt();
            weight[i] = cin.nextInt();
            value[i] = cin.nextInt();
        }
        int dp[][] = new int[v+1][m+1];
        for(int i = 1;i<=n;i++){
            for(int j = v;j>=vi[i];j--){
                for(int k = m;k>= weight[i];k--){
                    dp[j][k] = Math.max(dp[j][k],dp[j-vi[i]][k - weight[i]] + value[i]);
                }
            }
        }
        System.out.println(dp[v][m]);
    }
}

6.分组背包

6.1.算法思想

分组背包和01背包的区别就是，给定的物品是有分组的，每一组的物品最多只可以用一种。我们可以循环遍历一下每一组物品，进行01背包的操作。

6.2.例题与题解

分组背包问题

有 N 组物品和一个容量是 V 的背包。

每组物品有若干个，同一组内的物品最多只能选一个。
每件物品的体积是 vij ，价值是 wij ，其中 i 是组号，j 是组内编号。

求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。

输出最大价值。

输入格式

第一行有两个整数 N，V，用空格隔开，分别表示物品组数和背包容量。

接下来有 N 组数据：

  • 每组数据第一行有一个整数 Si，表示第 i 个物品组的物品数量；
  • 每组数据接下来有 Si 行，每行有两个整数 vij,wij，用空格隔开，分别表示第 i 个物品组的第 j 个物品的体积和价值；

输出格式

输出一个整数，表示最大价值。

数据范围

0<N,V≤100
0<Si≤100
0<vij,wij≤100

输入样例

3 5
2
1 2
2 4
1
3 4
1
4 5

输出样例：

8
import java.util.Scanner;

/**
 * @Author: stukk
 * @Description: TODO
 * @DateTime: 2023-04-12 11:15
 **/
public class Main {
    public static void main(String[] args) {
        Scanner cin  =new Scanner(System.in);
        int n = cin.nextInt();
        int v = cin.nextInt();
        int weight[][] = new int[101][101];
        int value[][] = new int[101][101];
        int s[] = new int[101];
        int dp[][] = new int[101][101];
        for(int i = 1;i<=n;i++){
            s[i] = cin.nextInt();
            for(int j = 1;j<=s[i];j++){
                weight[i][j] = cin.nextInt();
                value[i][j] = cin.nextInt();
            }
        }
        for(int i = 1;i <= n;i++){
            for(int j = 0;j<=v;j++){
                dp[i][j] = dp[i-1][j];
                for(int k = 1;k<=s[i];k++){
                    if(j >= weight[i][k]){
                        dp[i][j] = Math.max(dp[i][j],dp[i-1][j - weight[i][k]] + value[i][k]);
                    }
                }
            }
//            for(int j = 1;j<=s[i];j++){
//                for(int k = weight[i][j];k<= v;k++){
//                    dp[i][k] = Math.max(dp[i][k],dp[i-1][k-weight[i][j]] + value[i][j]);
//                }
//            }
        }
        System.out.println(dp[n][v]);
    }
}

7.依赖背包

有依赖的背包问题

有 N 个物品和一个容量是 V 的背包。

物品之间具有依赖关系，且依赖关系组成一棵树的形状。如果选择一个物品，则必须选择它的父节点。

如下图所示：

如果选择物品5，则必须选择物品1和2。这是因为2是5的父节点，1是2的父节点。

每件物品的编号是 i ，体积是 vi，价值是 wi ，依赖的父节点编号是 pi 。物品的下标范围是 1…N1。

求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。

输出最大价值。

输入格式

第一行有两个整数 N，V，用空格隔开，分别表示物品个数和背包容量。

接下来有 N 行数据，每行数据表示一个物品。
第 i 行有三个整数 vi,wi,pi ，用空格隔开，分别表示物品的体积、价值和依赖的物品编号。
如果 pi=−1，表示根节点。 数据保证所有物品构成一棵树。

输出格式

输出一个整数，表示最大价值。

数据范围

1≤N,V≤100
1≤vi,wi≤100

父节点编号范围：

  • 内部结点：1≤pi≤N1;
  • 根节点 pi=−1;

输入样例

5 7
2 3 -1
2 2 1
3 5 1
4 7 2
3 6 2

输出样例：

11
难度：困难
时/空限制：1s / 64MB
总通过数：15113
总尝试数：24316
来源：背包九讲
算法标签

挑战模式


import java.util.*;

/**
 * @Author: stukk
 * @Description: TODO
 * @DateTime: 2023-04-12 20:48
 **/
public class Main {
    private static int weight[],value[],root,dp[][],n,v;
    private static List<Integer> father[];
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        n = cin.nextInt();
        v = cin.nextInt();
        weight = new int[n+1];
        value = new int[n+1];
        father = new List[n+1];
        dp = new int[n+1][v+1];
        for(int i = 1;i <= n;i++){
            weight[i] = cin.nextInt();
            value[i] = cin.nextInt();
            int pi = cin.nextInt();
            if(pi == -1){
                root = i;
            }
            else{
                if(father[pi] == null){
                    father[pi] = new LinkedList<Integer>();
                }
                father[pi].add(i);
            }
        }
        dfs(root);
        System.out.println(dp[root][v]);
    }

    private static void dfs(int root) {
        for(int i = weight[root];i<=v;i++){
            dp[root][i] = value[root]; //放入这个节点
        }
        for(int i = 0;father[root] != null &&  i < father[root].size() ;i++){
            int to = father[root].get(i);
            dfs(to);
            for(int j = v;j>=weight[root];j--){
                for(int k = 0;k<= j - weight[root];k++){
                    dp[root][j] = Math.max(dp[root][j],dp[root][j - k] + dp[to][k]);
                }
            }
        }
    }
}

8.背包方案数

在01背包的基础上，使用一个数组用来保存方案数，如果最大价值相同，那么加上方案数量

背包问题求方案数

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。

第 i  件物品的体积是 vi ，价值是 wi 。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。

输出 最优选法的方案数。注意答案可能很大，请输出答案模 109+7 的结果。

输入格式

第一行两个整数，N，V ，用空格隔开，分别表示物品数量和背包容积。

接下来有 N 行，每行两个整数 vi,wi 用空格隔开，分别表示第 i 件物品的体积和价值。

输出格式

输出一个整数，表示 方案数 模 109+7109+7 的结果。

数据范围

0<N,V≤1000
0<vi,wi≤1000

输入样例

4 5
1 2
2 4
3 4
4 6

输出样例：

2
package 背包;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @Author: stukk
 * @Description: TODO
 * @DateTime: 2023-04-17 20:50
 **/
public class 背包方案 {
    public static void main(String[] args) {
        Scanner cin  =new Scanner(System.in);
        int n = cin.nextInt();
        int m = cin.nextInt();
        int mod = 1000000007;
        int weight[] = new int[n+1];
        int value[] = new int[n+1];
        for(int i = 1;i<=n;i++){
            weight[i] = cin.nextInt();
            value[i] = cin.nextInt();
        }
        int dp[] = new int[m+1];
        long num[] = new long[m+1];
        Arrays.fill(num,1);
        for(int i = 1;i<=n;i++){
            for(int j = m;j >= weight[i]; j--){
                int pi = Math.max(dp[j],dp[j-weight[i]] + value[i]);
                long cnt = 0;
                if(pi == dp[j]){
                    cnt = (cnt %mod + num[j]%mod)%mod;
                }
                if(pi == (dp[j-weight[i]] + value[i])) {
                    cnt = (cnt%mod + num[j-weight[i]]%mod)%mod;
                }
                num[j] = cnt%mod;
                dp[j] = pi;
            }
        }
        System.out.println(num[m]);
    }
}

9.求背包具体方案

背包问题求具体方案

import java.util.Arrays;
import java.util.Scanner;

/**
 * @Author: stukk
 * @Description: TODO
 * @DateTime: 2023-04-17 21:26
 **/
public class Main {
    public static void main(String[] args) {
        Scanner cin  =new Scanner(System.in);
        int n = cin.nextInt();
        int m = cin.nextInt();
        int weight[] = new int[n+1];
        int value[] = new int[n+1];
        for(int i = 1;i<=n;i++){
            weight[i] = cin.nextInt();
            value[i] = cin.nextInt();
        }
        int dp[][] = new int[n+2][m+2];
        for(int i = n;i >= 1;i--){
            for(int j = 0;j <= m; j++){
                dp[i][j] = dp[i+1][j];
                if(j >= weight[i])
                    dp[i][j] = Math.max(dp[i][j],dp[i+1][j-weight[i]] + value[i]);
            }
        }
        int ans = m;
        for(int i = 1;i<=n;i++){
            if(ans >= weight[i] && dp[i][ans] == dp[i+1][ans - weight[i]] + value[i]){
                ans -= weight[i];
                System.out.print(i+" ");
            }
        }
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/426686.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

嵌入式开发——串口常见问题和调试手段

嵌入式开发——串口常见问题和调试手段

1、串口介绍 参考博客&#xff1a;《ARM芯片&#xff08;S5PV210芯片&#xff09;——串口通信详解》、《UART和RS232、RS485的联系和区别、以及对软件编程的影响》&#xff1b; 2、串口常见问题 (1)内核没有开启串口&#xff0c;导致没有产生设备节点&#xff1b; (2)上层应用…
阅读更多...
运动想象脑电信号数据集及其预处理方法

运动想象脑电信号数据集及其预处理方法

脑电信号基础知识 在BCI应用中，获取脑信号的途径包括多种技术方式。其中，EEG是最适合脑机接口应用的技术，主要因为无创性、便携式和高时间分辨率是其的优势。EEG是记录头部表面不同位置之间电位差异的时间记录，它起源于分布在大脑皮层的数百万个神经元的同步电活动的总和。…
阅读更多...
我把Solon打包成了native image，速度快的惊人

我把Solon打包成了native image，速度快的惊人

Solon 一个高效的应用开发框架&#xff1a;更快、更小、更简单。https://solon.noear.org/ 我刚开始对 Solon 感兴趣的原因&#xff0c;就是启动快、包体积小&#xff0c;用了一段时间之后&#xff0c;发现 Solon 使用 GraalVM native iamge 打包有一些问题&#xff0c;我把问题…
阅读更多...
Cache；高速缓冲存储器

Cache；高速缓冲存储器

高速缓冲存储器 概述 ​ 在多体并行存储系统中&#xff0c;由于IO设备向主存请求的级别高于CPU访存&#xff0c;这就出现了CPU等待IO设备访存的现象&#xff0c;导致CPU空等一段时间&#xff0c;甚至等待几个周期&#xff0c;从而降低了CPU的工作效率&#xff0c;为了避免CPU…
阅读更多...
Eclipse环境搭建并且运行wordcount程序

Eclipse环境搭建并且运行wordcount程序

一、安装Hadoop插件 1. 所需环境 hadoop2.0伪分布式环境平台正常运行 所需压缩包&#xff1a;eclipse-jee-luna-SR2-linux-gtk-x86_64.tar.gz 　　　　　　　　　　在Linux环境下运行的eclipse软件压缩包,解压后文件名为eclipse 　　　　　　　　　　hadoop2x-eclipse-plugin-m…
阅读更多...
【Mysql】事物处理(TransAction Processing)

【Mysql】事物处理(TransAction Processing)

博主简介&#xff1a;想进大厂的打工人博主主页&#xff1a;xyk:所属专栏: JavaEE初阶最近在复习mysql&#xff0c;复习到了mysql事物处理&#xff08;TransAction&#xff09;&#xff0c;帮自己回顾一下&#xff0c;如果你也想了解什么是mysql的事物处理&#xff0c;希望这篇…
阅读更多...
【SQL Server】无需公网IP，就可以远程连接SQL Server数据库

【SQL Server】无需公网IP，就可以远程连接SQL Server数据库

目录 1.前言 2.本地安装和设置SQL Server 2.1 SQL Server下载 2.2 SQL Server本地连接测试 2.3 Cpolar内网穿透的下载和安装 2.3 Cpolar内网穿透的注册 3.本地网页发布 3.1 Cpolar云端设置 3.2 Cpolar本地设置 4.公网访问测试 5.结语 1.前言 数据库的重要性相信大家…
阅读更多...
基于html+css的自适应展示3

基于html+css的自适应展示3

准备项目 项目开发工具 Visual Studio Code 1.44.2 版本: 1.44.2 提交: ff915844119ce9485abfe8aa9076ec76b5300ddd 日期: 2020-04-16T16:36:23.138Z Electron: 7.1.11 Chrome: 78.0.3904.130 Node.js: 12.8.1 V8: 7.8.279.23-electron.0 OS: Windows_NT x64 10.0.19044 项目…
阅读更多...
MySQL--库的操作--校验规则对于数据库的影响--0409

MySQL--库的操作--校验规则对于数据库的影响--0409

目录 1.库的基础操作 查看数据库 创建数据库 删除数据库 查看建库语句 修改数据库 2.字符集和字符集校验规则 2.1 查看系统默认字符集以及校验规则 2.2 使用特定的字符集创建数据库 2.3 不同校验规则对数据库的影响 2.3.1 大小写验证 2.3.2 排序验证 3.备份和恢复 3.1…
阅读更多...
开启单细胞及空间组学行业发展黄金时代！首届国际单细胞及空间组学大会在穗闭幕

开启单细胞及空间组学行业发展黄金时代！首届国际单细胞及空间组学大会在穗闭幕

2023年4月16日&#xff0c;首届TICSSO国际单细胞及空间组学大会圆满闭幕&#xff0c;本次大会吸引了2000余位来自产、学、研、资、医、政、媒等业界人士齐聚羊城&#xff0c;注册总人数5398人&#xff0c;网络播放总量达548245人次&#xff0c;网络观看覆盖美国、德国、日本、澳…
阅读更多...
Vue语法糖＜script setup＞详解，用最快的方式让你看懂和＜script＞的区别

Vue语法糖＜script setup＞详解，用最快的方式让你看懂和＜script＞的区别

前言 Vue3出来已经3年了&#xff0c;但是前两天在百度上搜索有关setup语法糖的细节时&#xff0c;发现很多博客关于语法糖细节部分&#xff0c;还是讲的很粗糙&#xff0c;因此决定自己来写一篇入门的博客&#xff0c;方便大家快速上手。 <script setup>简介 它是Vue3…
阅读更多...
关于ASP.NET MVC与.NET CORE 的区别--小结

关于ASP.NET MVC与.NET CORE 的区别--小结

简述关于ASP.NET MVC与.NET CORE的区别 1、关于ASP.NET 关于MVC 刚开始接触这个技术的时候我经常不理解他们的名字&#xff0c;我相信许多学ASP.NET开发人员开始接触MVC应该也和我一样产生很多为什么&#xff0c;也会误认为认为MVC与ASP.NET完全没有关系&#xff0c;是一个全新…
阅读更多...
基于ssm+vue的学生实习过程管理系统

基于ssm+vue的学生实习过程管理系统

基于ssmvue的学生实习过程管理系统 ✌全网粉丝20W,csdn特邀作者、博客专家、CSDN新星计划导师、java领域优质创作者,博客之星、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ &#x1f345;文末获取项目下载方式&#x1f345; 一、项目背景介绍…
阅读更多...
Kotlin与H5通信的实现方式

Kotlin与H5通信的实现方式

Kotlin与H5通信1、H5中主动的调用Kotlin中的程序1编写后端程序并且在服务器上运行2准备好AndroidStudio的界面布局中的WebView3编写工具类用来处理H5调用逻辑4通过addJavascriptInterface来构建桥梁5结果展示2在Kotlin中调用H5的程序1在H5中编写方法&#xff0c;来处理Kotlin的…
阅读更多...
【C】Operator / Expression

【C】Operator / Expression

系列连载 【python / C / C】 参考 《C语言程序设计&#xff08;第四版&#xff09;谭浩强》【C语言】C语言视频教程《郝斌 C 语言自学教程》 文章目录1 运算符1.1 基本的算术运算符2 表达式1 运算符 1.1 基本的算术运算符 注意&#xff0c; 是右结合的 “” 具有左结合性&…
阅读更多...
C++ 面向对象、多继承

C++ 面向对象、多继承

// Student.hclass Student { private: // 私有的&#xff0c;外界不能访问char *name;int age;public:void setAge(int age);void setName(char* name);int getAge();char* getName();// 空参构造函数Student(){}// 一参构造函数Student(char* name) : Student(name,80) {// 调…
阅读更多...
干翻Hadoop系列：MapReduce详解

干翻Hadoop系列：MapReduce详解

第一章&#xff1a;MapReduce原理 数据存储在分布式文件系统中HDFS里边&#xff0c;通过使用Hadoop资源管理系统YARN&#xff0c;Hadoop可以将MapReduce计算&#xff0c;转移到有存储部分的数据的各台机器上。 一&#xff1a;概念和原理 1&#xff1a;MapReduce作业 MapRed…
阅读更多...
【机器学习】P16 激活函数 Activation Function

【机器学习】P16 激活函数 Activation Function

对于激活函数&#xff08;Activation Function&#xff09;&#xff0c;存在两个问题&#xff1a; 为什么要用激活函数&#xff1f;如何选择用哪种激活函数&#xff1f;如何使用激活函数&#xff1f; 本博文将围绕这两个问题&#xff0c;首先介绍激活函数的作用&#xff0c;从…
阅读更多...
2023腾讯云轻量应用服务器性能评测

2023腾讯云轻量应用服务器性能评测

腾讯云轻量应用服务器性能如何&#xff1f;CPU型号主频、内存、公网带宽和系统盘存储多维对比&#xff0c;轻量应用服务器会不会比云服务器CVM性能差&#xff1f;相对于CVM云服务器轻量服务器更适合轻量级的应用&#xff0c;轻量服务适合中小企或个人开发者用于搭建We网站b应用…
阅读更多...
利用Python生成和识读二维码（QR Code）和微二维码（Micro QR Code）

利用Python生成和识读二维码（QR Code）和微二维码（Micro QR Code）

目录一、环境准备二、二维码&#xff08;QR Code&#xff09;生成和读取2.1 生成二维码2.2 读取二维码三、微二维码&#xff08;Micro QR Code&#xff09;生成和读取3.1 生成微二维码3.2 读取微二维码之前写的一篇 博客采用了segno库来做微二维码的生成&#xff0c;该库可以方…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023