第十四届蓝桥杯省赛C++A组F题【买瓜】题解（AC）

news2024/7/6 18:11:23

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

70pts

题目要求我们在给定的瓜中选择一些瓜，可以选择将瓜劈成两半，使得最后的总重量恰好等于 m m m。我们的目标是求出至少需要劈多少个瓜。

首先，我们注意到每个瓜的重量最多为 1 0 9 10^9 109，而求和的重量 m m m 也最多为 1 0 9 10^9 109，每个瓜的重量最多只能被分为两份。同时，由于每个瓜可以选择劈或者不劈，所以我们可以使用深度优先搜索（DFS）来遍历所有可能的组合。

在深度优先搜索的过程中，我们需要记录当前考虑到的瓜的序号 u，当前已经选中瓜的总重量 s 以及已经劈开的瓜的数量 cnt。当满足以下条件之一时，当前搜索分支可以提前结束：

  • 当前已选瓜的总重量 s 大于目标重量 m；
  • 已经劈开的瓜的数量 cnt 大于等于目标重量 m，因为劈开的瓜越多，总重量越小，不可能达到 m。

当我们遍历到最后一个瓜时，检查当前选中瓜的总重量 s 是否等于目标重量 m，如果等于，则更新答案 res 为 cnt 和 res 中的较小值。

时间复杂度：

由于每个瓜都有三种选择，所以时间复杂度为 O ( 3 n ) O(3^n) O(3n)，其中 n n n 是瓜的个数。

95pts

由于 70pts 速度过慢，故需要优化，用了两个 DFS 函数（折半搜索），dfs_1 和 dfs_2，先对前一半的瓜进行搜索，将搜索结果存储在哈希表 h 中，然后对后一半的瓜进行搜索，同时在搜索过程中与哈希表 h 中的结果进行匹配，以找到满足条件的组合。

时间复杂度：

由于每个瓜都有三种选择，所以时间复杂度为 O ( 3 n 2 ) O(3^\frac{n}{2}) O(32n​)，其中 n n n 是瓜的个数。同时，由于在搜索过程中进行了剪枝，实际运行时间会小于 O ( 3 n 2 ) O(3^\frac{n}{2}) O(32n​)，又由于哈希表的常数过大，会导致程序缓慢，故无法通过所有数据。

100pts

本题要求从给定的瓜中选择一些瓜，可以对瓜进行劈开，使得最后选出的瓜的总重量恰好为 m m m，求最少需要劈开的瓜的个数。题目可以使用分治和二分查找的思路来解决。

首先，将所有的瓜按照重量进行排序。然后，将瓜分为两部分，前 n / 2 n/2 n/2 个瓜和后 n / 2 n/2 n/2 个瓜。对于每一部分，求出所有可能的瓜的重量组合以及对应的劈开的瓜的个数。接着，将前半部分的所有重量组合排序，方便后续使用二分查找。最后，遍历后半部分的所有重量组合，使用二分查找在前半部分寻找恰好使得总重量为 m m m 的组合，并记录最少需要劈开的瓜的个数。

具体实现如下：

  1. 读入瓜的个数 n 和目标重量 m，将目标重量 m 乘以 2 2 2，将题目转换成求瓜的重量恰好为 2 m 2m 2m 的组合。
  2. 读入每个瓜的重量，将瓜的重量也乘以 2 2 2。
  3. 对瓜的重量进行排序。
  4. 计算分界点 tn，将瓜分为前后两部分，前半部分为 [0, tn)，后半部分为 [tn, n)。
  5. 使用深度优先搜索遍历前半部分的所有组合，记录每种组合的总重量和需要劈开的瓜的个数，保存在数组 alls 中。
  6. 对 alls 数组进行排序，然后去重。
  7. 使用深度优先搜索遍历后半部分的所有组合，对于每种组合，使用二分查找在前半部分寻找恰好使得总重量为 2 m 2m 2m 的组合，并记录最少需要劈开的瓜的个数。
  8. 输出最少需要劈开的瓜的个数，如果不存在这样的组合，则输出 -1。

时间复杂度：

本题的时间复杂度主要取决于深度优先搜索和二分查找的复杂度。在最坏情况下，深度优先搜索需要遍历所有可能的组合，因此时间复杂度为 O ( 3 n 2 ) O(3^\frac{n}{2}) O(32n​)。二分查找的时间复杂度为 O ( log ⁡ n ) O(\log n) O(logn)。所以总的时间复杂度为 O ( 3 n 2 log ⁡ 3 n 2 + 3 n 2 ) O(3^\frac{n}{2} \log 3^\frac{n}{2} + 3^\frac{n}{2}) O(32n​log32n​+32n​)。

手写哈希表

由于部分平台数据较强，可能无法通过 100 % 100\% 100% 的数据，文末补充手写哈希表的做法，实测可通过 100 % 100\% 100% 数据。

AC_Code

  • C++（70%）
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 35;

int n, m, tn;
int w[N];
int res = 50;

void dfs(int u, LL s, int cnt)
{
    if (s > m || cnt >= m)
        return;
    if (s == m)
    {
        res = cnt;
        return;
    }
    if (u == n)
        return;
    
    dfs(u + 1, s, cnt);
    dfs(u + 1, s + w[u] / 2, cnt + 1);
    dfs(u + 1, s + w[u], cnt);
}

int main()
{
    cin >> n >> m, m *= 2;
    for (int i = 0; i < n; ++ i )
        cin >> w[i], w[i] *= 2;
    
    dfs(0, 0, 0);
    
    cout << (res == 50? -1: res) << endl;
    
    return 0;
}
  • Java（70%）
import java.util.Scanner;
import java.util.Arrays;

public class Main {
    private static final int N = 35;

    private static int n, m;
    private static int[] w = new int[N];
    private static int res = 50;

    public static void dfs(int u, long s, int cnt) {
        if (s > m || cnt >= m) {
            return;
        }
        if (s == m) {
            res = cnt;
            return;
        }
        if (u == n) {
            return;
        }

        dfs(u + 1, s, cnt);
        dfs(u + 1, s + w[u] / 2, cnt + 1);
        dfs(u + 1, s + w[u], cnt);
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        n = in.nextInt();
        m = in.nextInt();
        m *= 2;

        for (int i = 0; i < n; ++i) {
            w[i] = in.nextInt();
            w[i] *= 2;
        }

        dfs(0, 0, 0);

        System.out.println((res == 50 ? -1 : res));
    }
}
  • Python（65%）
from sys import stdin

N = 35

def dfs(u, s, cnt):
    if s > m or cnt >= m:
        return
    if s == m:
        global res
        res = cnt
        return
    if u == n:
        return

    dfs(u + 1, s, cnt)
    dfs(u + 1, s + w[u] // 2, cnt + 1)
    dfs(u + 1, s + w[u], cnt)

n, m = map(int, stdin.readline().split())
m *= 2
w = [int(x) * 2 for x in stdin.readline().split()]

res = 50

dfs(0, 0, 0)

print(-1 if res == 50 else res)
  • C++（95%）
#include <iostream>
#include <cstring>
#include <algorithm>
#include <unordered_map>

using namespace std;

typedef long long LL;

const int N = 35;

int n, m, tn;
int w[N];
int res = 50;
unordered_map<int, int> h;

void dfs_1(int u, LL s, int cnt)
{
    if (s > m)
        return;
    if (u == tn)
    {
        if (h.count(s))
            h[s] = min(h[s], cnt);
        else
            h[s] = cnt;
        return;
    }
    
    dfs_1(u + 1, s, cnt);
    dfs_1(u + 1, s + w[u] / 2, cnt + 1);
    dfs_1(u + 1, s + w[u], cnt);
}

void dfs_2(int u, LL s, int cnt)
{
    if (s > m || cnt > res)
        return;
    if (u == n)
    {   
        if (h.count(m - s))
            res = min(res, h[m - s] + cnt);
        return;
    }
    
    dfs_2(u + 1, s, cnt);
    dfs_2(u + 1, s + w[u] / 2, cnt + 1);
    dfs_2(u + 1, s + w[u], cnt);
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    cin >> n >> m, m *= 2;
    for (int i = 0; i < n; ++ i )
        cin >> w[i], w[i] *= 2;
    
    sort(w, w + n);
    
    tn = max(0, n / 2 - 2);
    
    dfs_1(0, 0, 0);
    dfs_2(tn, 0, 0);
    
    cout << (res == 50? -1: res) << endl;
    
    return 0;
}
  • Java（95%）
import java.util.HashMap;
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    private static final int N = 35;

    private static int n, m, tn;
    private static int[] w = new int[N];
    private static int res = 50;
    private static HashMap<Integer, Integer> h = new HashMap<>();

    public static void dfs_1(int u, long s, int cnt) {
        if (s > m) {
            return;
        }
        if (u == tn) {
            h.put((int)s, h.getOrDefault((int)s, cnt));
            return;
        }

        dfs_1(u + 1, s, cnt);
        dfs_1(u + 1, s + w[u] / 2, cnt + 1);
        dfs_1(u + 1, s + w[u], cnt);
    }

    public static void dfs_2(int u, long s, int cnt) {
        if (s > m || cnt > res) {
            return;
        }
        if (u == n) {
            if (h.containsKey((int)(m - s))) {
                res = Math.min(res, h.get((int)(m - s)) + cnt);
            }
            return;
        }

        dfs_2(u + 1, s, cnt);
        dfs_2(u + 1, s + w[u] / 2, cnt + 1);
        dfs_2(u + 1, s + w[u], cnt);
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        n = in.nextInt();
        m = in.nextInt();
        m *= 2;

        for (int i = 0; i < n; ++i) {
            w[i] = in.nextInt();
            w[i] *= 2;
        }

        Arrays.sort(w, 0, n);

        tn = Math.max(0, n / 2 - 2);

        dfs_1(0, 0, 0);
        dfs_2(tn, 0, 0);

        System.out.println((res == 50 ? -1 : res));
    }
}
  • Python（80%）
from itertools import combinations

def dfs_1(u, s, cnt):
    if s > m:
        return
    if u == tn:
        if s in h:
            h[s] = min(h[s], cnt)
        else:
            h[s] = cnt
        return

    dfs_1(u + 1, s, cnt)
    dfs_1(u + 1, s + w[u] // 2, cnt + 1)
    dfs_1(u + 1, s + w[u], cnt)

def dfs_2(u, s, cnt):
    global res  # 声明 res 为全局变量
    if s > m or cnt > res:
        return
    if u == n:
        if m - s in h:
            res = min(res, h[m - s] + cnt)
        return

    dfs_2(u + 1, s, cnt)
    dfs_2(u + 1, s + w[u] // 2, cnt + 1)
    dfs_2(u + 1, s + w[u], cnt)

n, m = map(int, input().split())
m *= 2
w = list(map(int, input().split()))
w = [x * 2 for x in w]

w.sort()

tn = max(0, n // 2 - 2)

h = {}
res = 50

dfs_1(0, 0, 0)
dfs_2(tn, 0, 0)

print(-1 if res == 50 else res)
  • C++（100%）
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>

#define x first
#define y second

using namespace std;

typedef long long LL;
typedef pair<int, int> PII;

const int N = 35;

int n, m, tn, t;
int w[N];
int res = 50;
PII alls[1 << 21];

void dfs_1(int u, LL s, int cnt)
{
    if (s > m)
        return;
    if (u == tn)
    {
        alls[t ++] = {s, cnt};
        return;
    }
    
    dfs_1(u + 1, s, cnt);
    dfs_1(u + 1, s + w[u], cnt);
    dfs_1(u + 1, s + w[u] / 2, cnt + 1);
}

void dfs_2(int u, LL s, int cnt)
{
    if (s > m || cnt >= res)
        return;
    if (u == n)
    {   
        int l = 0, r = t - 1;
        while (l < r)
        {
            int mid = l + r >> 1;
            if (alls[mid].x + s >= m)
                r = mid;
            else
                l = mid + 1;
        }
        
        if (alls[l].x + s == m)
            res = min(res, alls[l].y + cnt);
        
        return;
    }
    
    dfs_2(u + 1, s, cnt);
    dfs_2(u + 1, s + w[u], cnt);
    dfs_2(u + 1, s + w[u] / 2, cnt + 1);
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    cin >> n >> m, m *= 2;
    for (int i = 0; i < n; ++ i )
        cin >> w[i], w[i] *= 2;
    
    sort(w, w + n);
    
    tn = max(0, n / 2 - 2);
    
    dfs_1(0, 0, 0);
    
    sort(alls, alls + t);
    int k = 1;
    for (int i = 1; i < t; ++ i )
        if (alls[i].x != alls[i - 1].x)
            alls[k ++] = alls[i];
    t = k;
    
    dfs_2(tn, 0, 0);
    
    cout << (res == 50? -1: res) << endl;
    
    return 0;
}
  • Java（100%）
import java.io.*;
import java.util.*;

public class Main {
    private static final int N = 35;

    private int n, m, tn, t;
    private int[] w = new int[N];
    private int res = 50;
    private Pair[] alls = new Pair[1 << 21];

    public static void main(String[] args) throws IOException {
        Main main = new Main();
        main.solve();
    }

    private void solve() throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

        String[] input = in.readLine().split(" ");
        n = Integer.parseInt(input[0]);
        m = Integer.parseInt(input[1]) * 2;

        input = in.readLine().split(" ");
        for (int i = 0; i < n; ++i) {
            w[i] = Integer.parseInt(input[i]) * 2;
        }

        Arrays.sort(w, 0, n);

        tn = Math.max(0, n / 2 - 2);

        dfs_1(0, 0, 0);

        Arrays.sort(alls, 0, t, Comparator.comparingInt(Pair::getX));

        int k = 1;
        for (int i = 1; i < t; ++i) {
            if (alls[i].x != alls[i - 1].x) {
                alls[k++] = alls[i];
            }
        }
        t = k;

        dfs_2(tn, 0, 0);

        out.println(res == 50 ? -1 : res);
        out.flush();
    }

    private void dfs_1(int u, long s, int cnt) {
        if (s > m)
            return;
        if (u == tn) {
            alls[t++] = new Pair((int) s, cnt);
            return;
        }

        dfs_1(u + 1, s, cnt);
        dfs_1(u + 1, s + w[u], cnt);
        dfs_1(u + 1, s + w[u] / 2, cnt + 1);
    }

    private void dfs_2(int u, long s, int cnt) {
        if (s > m || cnt >= res)
            return;
        if (u == n) {
            int l = 0, r = t - 1;
            while (l < r) {
                int mid = l + r >> 1;
                if (alls[mid].x + s >= m)
                    r = mid;
                else
                    l = mid + 1;
            }

            if (alls[l].x + s == m)
                res = Math.min(res, alls[l].y + cnt);

            return;
        }

        dfs_2(u + 1, s, cnt);
        dfs_2(u + 1, s + w[u], cnt);
        dfs_2(u + 1, s + w[u] / 2, cnt + 1);
    }

    static class Pair {
        int x, y;

        Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }

        int getX() {
            return x;
        }
    }
}
  • Python（100%）
import sys
from typing import List, Tuple

N = 35

n, m, tn, t = 0, 0, 0, 0
w = [0] * N
res = 50
alls: List[Tuple[int, int]] = [(0, 0)] * (1 << 21)


def dfs_1(u: int, s: int, cnt: int):
    global t, alls
    if s > m:
        return
    if u == tn:
        alls[t] = (s, cnt)
        t += 1
        return

    dfs_1(u + 1, s, cnt)
    dfs_1(u + 1, s + w[u], cnt)
    dfs_1(u + 1, s + w[u] // 2, cnt + 1)


def dfs_2(u: int, s: int, cnt: int):
    global res, alls
    if s > m or cnt >= res:
        return
    if u == n:
        l, r = 0, t - 1
        while l < r:
            mid = (l + r) // 2
            if alls[mid][0] + s >= m:
                r = mid
            else:
                l = mid + 1

        if alls[l][0] + s == m:
            res = min(res, alls[l][1] + cnt)

        return

    dfs_2(u + 1, s, cnt)
    dfs_2(u + 1, s + w[u], cnt)
    dfs_2(u + 1, s + w[u] // 2, cnt + 1)


def main():
    global n, m, tn, t, w, alls, res

    n, m = map(int, sys.stdin.readline().strip().split())
    m *= 2
    w = list(map(int, sys.stdin.readline().strip().split()))
    w = [x * 2 for x in w]

    w.sort()

    tn = max(0, n // 2 - 2)

    dfs_1(0, 0, 0)

    alls = sorted(alls[:t], key=lambda x: x[0])

    k = 1
    for i in range(1, t):
        if alls[i][0] != alls[i - 1][0]:
            alls[k] = alls[i]
            k += 1
    t = k

    dfs_2(tn, 0, 0)

    print(-1 if res == 50 else res)


if __name__ == "__main__":
    main()
  • C++（手写哈希表 100%）
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>

#define x first
#define y second

using namespace std;

typedef long long LL;
typedef pair<int, int> PII;

const int N = 35, M = 1e7 + 7, null = 2e9 + 7;

int n, m, tn, t;
int w[N];
int res = N;
PII h[M];

int find(int s)
{
    int k = s % M;
    
    while (h[k].x != s && h[k].x != null)
    {
        k ++;
        if (k == M)
            k = 0;
    }
    
    return k;
}

void dfs_1(int u, LL s, int cnt)
{
    if (s > m)
        return;
    if (u == tn)
    {
        int k = find(s);
        h[k] = {s, min(h[k].y, cnt)};
        return;
    }
    
    dfs_1(u + 1, s, cnt);
    dfs_1(u + 1, s + w[u], cnt);
    dfs_1(u + 1, s + w[u] / 2, cnt + 1);
}

void dfs_2(int u, LL s, int cnt)
{
    if (s > m || cnt >= res)
        return;
    if (u == n)
    {   
        int tar = m - s;
        int k = find(tar);
        if (h[k].x != null)
            res = min(res, cnt + h[k].y);
        return;
    }
    
    dfs_2(u + 1, s, cnt);
    dfs_2(u + 1, s + w[u], cnt);
    dfs_2(u + 1, s + w[u] / 2, cnt + 1);
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    cin >> n >> m, m <<= 1;
    for (int i = 0; i < n; ++ i )
        cin >> w[i], w[i] <<= 1;
    
    for (int i = 1; i < M; ++ i )
        h[i] = {null, null};
    
    sort(w, w + n);
    
    tn = max(0, n / 2 - 1);
    
    dfs_1(0, 0, 0);
    
    dfs_2(tn, 0, 0);
    
    cout << (res == N? -1: res) << '\n';
    
    return 0;
}

【在线测评】

在这里插入图片描述

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

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

相关文章

Linux高并发服务器开发（八）Socket和TCP

Linux高并发服务器开发（八）Socket和TCP

文章目录 1 IPV4套接字结构体2 TCP客户端函数 3 TCP服务器流程函数代码粘包 4 三次握手5 四次挥手6 滑动窗口 1 IPV4套接字结构体 2 TCP客户端 特点&#xff1a;出错重传 每次发送数据对方都会回ACK&#xff0c;可靠 tcp是打电话的模型&#xff0c;建立连接 使用连接 关闭连接…
阅读更多...
探索SOLIDWORKS 2024设计增强功能

探索SOLIDWORKS 2024设计增强功能

随着技术的不断进步和市场的日益竞争&#xff0c;工程设计和制造行业对于快捷、准确和创新的工具需求日益增长。SOLIDWORKS作为3D CAD设计软件&#xff0c;一直致力于为用户提供更强大、更便捷的设计工具。SOLIDWORKS 2024的发布&#xff0c;再次证明了其在设计增强功能方面的持…
阅读更多...
代码随想录算法训练营Day55|42.接雨水、84.柱状图中最大的矩形

代码随想录算法训练营Day55|42.接雨水、84.柱状图中最大的矩形

接雨水 42. 接雨水 - 力扣&#xff08;LeetCode&#xff09; 暴力解法 对计算接到的雨水&#xff0c;有两种方式&#xff0c;一是按照行来计算。 另一种是按列计算 按列计算容易不乱。基本思路如下&#xff1a; 对每列i进行循环&#xff0c;在循环中&#xff0c;找到该列左…
阅读更多...
python-逻辑语句

python-逻辑语句

if else语句 不同于C&#xff1a;else if range语句&#xff1a; continue continue的作用是&#xff1a; 中断所在循环的当次执行&#xff0c;直接进入下一次 continue在嵌套循环中的应用 break 直接结束所在的循环 break在嵌套循环中的应用 continue和break&#xff0c;在…
阅读更多...
【TB作品】atmega16 计算器，ATMEGA16单片机，Proteus仿真

【TB作品】atmega16 计算器，ATMEGA16单片机，Proteus仿真

实验报告&#xff1a;基于ATmega16单片机的简易计算器设计 1. 实验背景 计算器是日常生活和工作中不可或缺的工具&#xff0c;通过按键输入即可实现基本的四则运算。通过本实验&#xff0c;我们将利用ATmega16单片机、矩阵键盘和LCD1602显示屏&#xff0c;设计并实现一个简易…
阅读更多...
【TB作品】智能台灯，ATMEGA16单片机，Proteus仿真

【TB作品】智能台灯，ATMEGA16单片机，Proteus仿真

智能台灯 1 adc检测光强光敏电阻 显示电压 2 光强太高 也就是高于临界值 就关闭小灯 3 光强太低 也就是低于临界值 就打开小灯 3 按键修改临界值 显示 实验报告&#xff1a;基于ATMEGA16单片机的智能台灯设计与Proteus仿真 1. 实验背景 智能台灯是一种能够根据环境光强自动调…
阅读更多...
【Altium】AD-焊盘介绍

【Altium】AD-焊盘介绍

【更多软件使用问题请点击亿道电子官方网站】 1、 文档目标 介绍PCB设计工具中焊盘的组成 2、 知识点 为元件创建封装时&#xff0c;焊盘都是不可获取的部分&#xff0c;一个完整的焊盘&#xff0c;包含了哪些部分&#xff0c;各自又是什么作用。 3、软硬件环境 1&#xff…
阅读更多...
算法笔记：模拟过程（螺旋遍历矩阵）

算法笔记：模拟过程（螺旋遍历矩阵）

1 模拟过程 “模拟过程题”通常指的是那些要求编程者通过编写代码来“模拟”或重现某个过程、系统或规则的题目。这类题目往往不涉及复杂的数据结构或高级算法&#xff0c;而是侧重于对给定规则的精确执行和逻辑的清晰表达。 其中螺旋遍历矩阵的题目就是一类典型的模拟过程题…
阅读更多...
学习笔记（linux高级编程）7

学习笔记（linux高级编程）7

2._exit 系统调用 void _exit(int status); 功能: 让进程退出,不刷新缓存区 参数: status:进程退出状态 返回值: 缺省 回调函数 3.atexit int atexit(void (*function)(void)); 功能: 注册进程退出前执行的函数 参数: function:函数指针 指向void返回值void参数的函数指针 返…
阅读更多...
吴恩达《LangChain for LLM Application Development》课程笔记

吴恩达《LangChain for LLM Application Development》课程笔记

目录 1. 前言 2. 课程笔记 2.1. 模型、提示和解析器 2.2. LLM记忆&#xff0c;上下文管理 2.3. 链式操作 2.4. 文档问答 2.4.1. stuff 方法 2.4.2. 其他方法 2.5. LLM应用评估 2.6. 代理 2.6.1. 预定义工具 2.6.2. 自定义工具 代码资源&#xff1a; 1. 前言 LangC…
阅读更多...
汇聚荣拼多多电商好不好？

汇聚荣拼多多电商好不好？

拼多多电商好不好?这是一个值得探讨的问题。拼多多作为中国领先的电商平台之一&#xff0c;以其独特的商业模式和创新的营销策略吸引了大量用户。然而&#xff0c;对于这个问题的回答并不是简单的好或不好&#xff0c;而是需要从多个方面进行综合分析。 一、商品质量 来看拼多…
阅读更多...
混合专家模型（MoE）的前世今生

混合专家模型（MoE）的前世今生

在文章《聊聊最近很火的混合专家模型&#xff08;MoE&#xff09;》中&#xff0c;我们简单介绍了MoE模型的定义和设计&#xff0c;并且比较了MoE和Dense模型的区别&#xff0c;今天我们继续来回顾一下MoE模型发展的历史和最新的发展现状。 从去年GPT-4发布至今&#xff0c;MoE…
阅读更多...
AIGC重塑创意设计：不仅能带来新技术，更能引发新思考

AIGC重塑创意设计：不仅能带来新技术，更能引发新思考

随着科技的飞速发展&#xff0c;AIGC&#xff08;生成式人工智能&#xff09;已经逐渐成为创意设计领域的一股新势力。从影视制作到游戏设计&#xff0c;从平面广告到数字媒体&#xff0c;AIGC的影响力无处不在&#xff0c;它不仅带来了全新的技术手段&#xff0c;更在深层次上…
阅读更多...
[SAP ABAP] 数据字典

[SAP ABAP] 数据字典

ABAP数据字典是定义和管理数据库对象的工具 系统的所有全局数据类型以及数据库表结构等都需要在数据字典中创建和维护(数据字典中的对象对所有ABAP程序都是全局的) 通过数据字典&#xff0c;我们可以把数据库对象管理好&#xff0c;后续才能顺利的进行功能开发&#xff0c;SA…
阅读更多...
安全为基、创新驱动，Soul App创始人张璐团队大力筑牢社交平台发展之基

安全为基、创新驱动，Soul App创始人张璐团队大力筑牢社交平台发展之基

随着技术的不断进步,AIGC在各个领域的应用日益广泛。在社交领域,AIGC社交为用户带来了更加高质量、个性化的社交体验,但同时也伴随着数据隐私泄露、网络诈骗和不良信息误导等风险。因此,社交平台在抓住AIGC技术发展机遇的同时,也要警惕技术所带来的风险。新型社交平台Soul App坚…
阅读更多...
15_软件程序设计基础

15_软件程序设计基础

目录 嵌入式软件开发原理 宿主机和目标机 交叉编译 交叉调试 嵌入式软件开发特点和挑战 开发工具 程序设计语言基本概念 解释和编译 常见程序设计语言 程序设计语言的基本成分 编译程序基本原理 嵌入式软件开发原理 宿主机和目标机 嵌入式软件开发不同于传统软件开…
阅读更多...
IO-Link OD介绍

IO-Link OD介绍

IO-Link OD&#xff08;On-request Data&#xff0c;按需数据&#xff09;是IO-Link通信中的一种重要数据类型&#xff0c;主要用于参数读写、指令交互、事件上传等动作。以下是关于IO-Link OD的结构、构成以及功能使用的详细说明&#xff1a; 结构与构成 定义&#xff1a;OD…
阅读更多...
星火认知大模型Spark3.5 api调用 #AI夏令营 #Datawhale #夏令营

星火认知大模型Spark3.5 api调用 #AI夏令营 #Datawhale #夏令营

环境安装 pip install --upgrade -q spark_ai_python 官网注册 链接&#xff1a;https://console.xfyun.cn/app/myapp 官方会在报名成功后&#xff0c;立即发放星火大模型 Spark Max的 API 额度助力我们完成赛事&#xff0c; 200w Tokens 任你花&#xff01; 暑期有四场夏令营…
阅读更多...
ADS基础教程23 - 有限元电磁仿真（FEM）可视化操作

ADS基础教程23 - 有限元电磁仿真（FEM）可视化操作

EM介绍 一、引言二、FEM可视化操作流程1.打开可视化界面2.查看介质的网格3.设置网格颜色4.选择网格5.传感器选择6.编辑传感器7.选择频率8.动画 三、总结 一、引言 在ADS基础教程22中介绍了如何在ADS进行有限元电磁仿真&#xff08;FEM&#xff09;&#xff0c;本文将继续介绍F…
阅读更多...
MSVCR120.DLL丢失的多种修复方法，助你快速解决dll问题

MSVCR120.DLL丢失的多种修复方法，助你快速解决dll问题

在日常生活和工作中&#xff0c;电脑已经成为我们不可或缺的工具。然而&#xff0c;在使用电脑的过程中&#xff0c;我们常常会遇到一些问题&#xff0c;其中之一就是电脑运行软件时提示找不到msvcr120.dll。如果该文件缺失或损坏&#xff0c;可能会导致依赖它的应用程序无法启…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023