【备战秋招】每日一题:4月8日美团春招第四题:题面+题目思路 + C++/python/js/Go/java带注释

news2025/10/28 9:43:41

为了更好的阅读体检，为了更好的阅读体检，，可以查看我的算法学习博客第四题-田地行走

在线评测链接:P1169

题目描述

塔子哥是一个农民，他有一片 n \times m 大小的田地，共 n 行 m 列，其中行和列都用从 1 开始的整数编号，田地中有 k 个格子中埋有土豆。我们记第 a 行第 b 列的格子为 (a, b) 。塔子哥现在位于 (x1, y1) ，他想要移动到 (x2, y2) 处去收菜，但是他不想阻碍自己土地里土豆的生长情况，所以他不想在移动过程中碰到土豆。

塔子哥每次移动可以移动到与他所处格子的相邻的一格中，形式化地说，如果塔子哥位于 (x, y) ，则塔子哥可以移动到 (x-1, y) ， (x+1, y) ， (x, y-1) ， (x, y+1) 的格子之一，但塔子哥不能移动到田地之外。

塔子哥想要在移动过程中，离这些土豆越远越好，而不是走最短路径。

这里定义两个格子之间的距离为曼哈顿距离，即格子 (a, b) 和 (c, d) 之间的距离是 |a-c|+|b-d| 。

塔子哥想知道，移动中与土豆之间距离的最小值最大可能是多少。

请注意，如果无论塔子哥如何移动，都会进入一个有土豆的格子的话，这个最大可能值为 0 。

输入描述

第一行三个整数 n， m ， k ，分别表示田地的行数，列数和土豆个数。

接下来 k 行，每行两个整数 p ， q ，表示一个土豆放置在格子 (p, q) 中。任意两土豆的放置位置不同。

接下来一行四个整数 x1 ， y1， x2 ， y2 ，表示塔子哥的出发位置和目的位置。保证塔子哥的出发位置和目的位置上没有土豆。

对于全部数据，

1 \le n, m \le 500 ，

n \times m \ge 3，

1 \le k \le min\{n \times m-2, 400\}，

1 \le p, x1, x2 \le n ，

1 \le q,y1, y2 \le m, (x1, y1) \neq (x2, y2)，

保证 (x1, y1) 和 (x2, y2) 中没有土豆，并且一个格子中最多放置一个土豆。

输出描述

输出一行一个整数，表示移动过程中与土豆之间距离的最小值的可能最大值。

样例

输入

5 6 2
2 1
2 3
1 1 5 1

输出

1

思路

二分答案 + BFS

想要最大化 从 (sx, sy) 到 (tx, ty) 的所有路径中，和所有土豆最近的距离，假设我们设定距离为 d ，则和任意一个土豆的距离小于 d 的点都可以看成不可走的点。所以二分这个 d ，然后 check 是否满足要求。

单调性证明

如果 d 满足，那么 d - 1 必然满足，但是 d + 1 不一定满足，所以这部分就具有单调性，那么通过二分答案来解决该问题就具有了正确性。

复杂度优化

现在的问题在于，如何快速获取一个点到所有土豆的距离中的最近距离?

一种显然的方式是从每个土豆都开始 bfs，最多有 400 个土豆，总操作次数就是 400 \times n\times m \approx 1e8，这个是比较极限的。

但是可以通过建立一个虚拟源点，这个源点到所有土豆的距离为 0 ，图中任意两点的距离为曼哈顿距离，如此就又变成了单源 bfs，bfs 中每个点只会被一个点更新，故求每个点到所有土豆的距离中的最近距离这部分，时间复杂度为 O(nm)

时间复杂度：O(mm + nm\log (n+m))

类似题目推荐

本题难度较大，请大家耐心练习！这里给大家推荐一些二分答案的题目!

LeetCode

  1. 1631. 最小体力消耗路径

  2. 778. 水位上升的泳池中游泳

  3. 1162. 地图分析

Codefun2000

  1. P1189. 华为实习 2023.04.12-实习笔试-第一题-购物系统的降级策略

  2. P1106. 腾讯音乐 2023.3.23-第二题-划分字符串

  3. P1006. 华为秋招 2022.9.21-数组取min

  4. P1093. 米哈游 2023.03.19-第三题-塔子哥的无限字符串

  5. P1086 携程 2023.3.16-二维矩阵可传送的最短路

代码

CPP

#include <bits/stdc++.h>
using namespace std;
​
const int N = 510;
const int INF = 0x3f3f3f3f;
int g[N][N];
int dist[N][N];
int vis[N][N];
int n, m, k;
int sx, sy, tx, ty;
​
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
vector<pair<int, int>> q(N * N);
​
// check 即按照 mid 这个最近距离，任何到任意一个点的距离小于 mid 的点都不可到达
bool check(int mid) {
    int hh = 0, tt = -1;
    q[++tt] = {sx, sy};
    vis[sx][sy] = true;
    bool is_find = false;
    while (hh <= tt) {
        int x = q[hh].first, y = q[hh].second;
        hh += 1;
        // 上下左右四个方向遍历
        for (int i = 0; i < 4; ++i) {
            int nx = x + dx[i], ny = y + dy[i];
            if (nx >= 1 && nx <= n && ny >= 1 && ny <= m && dist[nx][ny] >= mid && !vis[nx][ny]) {
                vis[nx][ny] = true;
                q[++tt] = {nx, ny};
                if (nx == tx && ny == ty) {
                    is_find = true;
                    break;
                }
            }
        }
        // 如果找到一条路径，提前退出，避免后续多余的搜索
        if (is_find) break;
    }
​
    bool ans = vis[tx][ty];
    // 将到达过的点全部标记为空，方便下一次遍历，无需清空整个数组
    for (int i = 0; i <= tt; ++i) vis[q[i].first][q[i].second] = false;
    return ans;
}
​
int main()
{
    scanf("%d%d%d", &n, &m, &k);
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= m; ++j)
            dist[i][j] = INF;
​
    int hh = 0, tt = -1;
    for (int a = 1; a <= k; ++a) {
        int x, y;
        scanf("%d%d", &x, &y);
        dist[x][y] = 0;
        q[++tt] = {x, y};
    }
​
    while (hh <= tt) {
        int x = q[hh].first, y = q[hh].second;
        hh += 1;
        for (int i = 0; i < 4; ++i) {
            int nx = x + dx[i], ny = y + dy[i];
            if (nx >= 1 && nx <= n && ny >= 1 && ny <= m && dist[nx][ny] > dist[x][y] + 1) {
                dist[nx][ny] = dist[x][y] + 1;
                q[++tt] = {nx, ny};
            }
        }
    }
​
    scanf("%d%d%d%d", &sx, &sy, &tx, &ty);
​
    // 二分答案，最大为 min(dist[sx][sy], dist[tx][ty])
    int l = 0, r = min(dist[sx][sy], dist[tx][ty]);
    while (l < r) {
        int mid = (l + r + 1) >> 1;
        if (check(mid)) l = mid;
        else r = mid - 1;
    }
    
    printf("%d\n", l);
​
    return 0;
}

python

N = 510
INF = 0x3f3f3f3f
g = [[0] * N for _ in range(N)]
dist = [[INF] * N for _ in range(N)]
vis = [[False] * N for _ in range(N)]
dx = [-1, 0, 1, 0]
dy = [0, 1, 0, -1]
q = [None] * (N * N)
n, m, k = map(int, input().split())
​
hh, tt = 0, -1
for a in range(1, k+1):
    x, y = map(int, input().split())
    dist[x][y] = 0
    tt += 1
    q[tt] = (x, y)
​
while hh <= tt:
    x, y = q[hh]
    hh += 1
    # 上下左右四个方向遍历
    for i in range(4):
        nx, ny = x + dx[i], y + dy[i]
        if 1 <= nx <= n and 1 <= ny <= m and dist[nx][ny] > dist[x][y] + 1:
            dist[nx][ny] = dist[x][y] + 1
            tt += 1
            q[tt] = (nx, ny)
​
sx, sy, tx, ty = map(int, input().split())
​
# check 即按照 mid 这个最近距离，任何到任意一个点的距离小于 mid 的点都不可到达
def check(mid):
    hh, tt = 0, -1
    tt += 1
    q[tt] = (sx, sy)
    vis[sx][sy] = True
    is_find = False
    while hh <= tt:
        x, y = q[hh]
        hh += 1
        for i in range(4):
            nx, ny = x + dx[i], y + dy[i]
            if 1 <= nx <= n and 1 <= ny <= m and dist[nx][ny] >= mid and not vis[nx][ny]:
                vis[nx][ny] = True
                tt += 1
                q[tt] = (nx, ny)
                if nx == tx and ny == ty:
                    is_find = True
                    break
        # 如果找到一条路径，提前退出，避免后续多余的搜索
        if is_find:
            break
    ans = vis[tx][ty]
    # 将到达过的点全部标记为空，方便下一次遍历，无需清空整个数组
    for i in range(tt+1):
        vis[q[i][0]][q[i][1]] = False
    return ans
​
​
# 二分答案，最大为 min(dist[sx][sy], dist[tx][ty])
l, r = 0, min(dist[sx][sy], dist[tx][ty])
while l < r:
    mid = (l + r + 1) >> 1
    if check(mid):
        l = mid
    else:
        r = mid - 1
​
print(l)
​

Java

import java.util.*;
​
public class Main {
    private static final int N = 510;
    private static final int INF = 0x3f3f3f3f;
    private static int[][] g = new int[N][N];
    private static int[][] dist = new int[N][N];
    private static boolean[][] vis = new boolean[N][N];
    private static int n, m, k;
    private static int sx, sy, tx, ty;
​
    private static int[] dx = {-1, 0, 1, 0};
    private static int[] dy = {0, 1, 0, -1};
    private static int[][] q = new int[N * N][2];
​
    // check 即按照 mid 这个最近距离，任何到任意一个点的距离小于 mid 的点都不可到达
    private static boolean check(int mid) {
        int hh = 0, tt = -1;
        q[++tt] = new int[]{sx, sy};
        vis[sx][sy] = true;
        boolean is_find = false;
        while (hh <= tt) {
            int x = q[hh][0], y = q[hh][1];
            hh += 1;
            // 上下左右四个方向遍历
            for (int i = 0; i < 4; ++i) {
                int nx = x + dx[i], ny = y + dy[i];
                if (nx >= 1 && nx <= n && ny >= 1 && ny <= m && dist[nx][ny] >= mid && !vis[nx][ny]) {
                    vis[nx][ny] = true;
                    q[++tt] = new int[]{nx, ny};
                    if (nx == tx && ny == ty) {
                        is_find = true;
                        break;
                    }
                }
            }
            // 如果找到一条路径，提前退出，避免后续多余的搜索
            if (is_find) break;
        }
​
        boolean ans = vis[tx][ty];
        // 将到达过的点全部标记为空，方便下一次遍历，无需清空整个数组
        for (int i = 0; i <= tt; ++i) vis[q[i][0]][q[i][1]] = false;
        return ans;
    }
​
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        k = sc.nextInt();
        for (int i = 1; i <= n; ++i) {
            Arrays.fill(dist[i], INF);
        }
​
        int hh = 0, tt = -1;
        for (int a = 1; a <= k; ++a) {
            int x = sc.nextInt();
            int y = sc.nextInt();
            dist[x][y] = 0;
            q[++tt] = new int[]{x, y};
        }
​
        while (hh <= tt) {
            int x = q[hh][0], y = q[hh][1];
            hh += 1;
            for (int i = 0; i < 4; ++i) {
                int nx = x + dx[i], ny = y + dy[i];
                if (nx >= 1 && nx <= n && ny >= 1 && ny <= m && dist[nx][ny] > dist[x][y] + 1) {
                    dist[nx][ny] = dist[x][y] + 1;
                    q[++tt] = new int[]{nx, ny};
                }
            }
        }
​
        sx = sc.nextInt();
        sy = sc.nextInt();
        tx = sc.nextInt();
        ty = sc.nextInt();
​
        // 二分答案，最大为 min(dist[sx][sy], dist[tx][ty])
        int l = 0, r = Math.min(dist[sx][sy], dist[tx][ty]);
        while (l < r) {
            int mid = (l + r + 1) >> 1;
            if (check(mid)) l = mid;
            else r = mid - 1;
        }
​
        System.out.println(l);
    }
}

Go

package main
​
import (
    "bufio"
    "fmt"
    "os"
)
​
const N = 510
const INF = 0x3f3f3f3f
​
var (
    g              [N][N]int
    dist           [N][N]int
    vis            [N][N]bool
    q              [N * N]pair
    n, m           int
    k              int
    sx, sy, tx, ty int
)
​
type pair struct {
    first, second int
}
​
var dx = []int{-1, 0, 1, 0}
var dy = []int{0, 1, 0, -1}
​
// check 即按照 mid 这个最近距离，任何到任意一个点的距离小于 mid 的点都不可到达
func check(mid int) bool {
    hh, tt := 0, 0
    q[tt] = pair{sx, sy}
    vis[sx][sy] = true
    isFind := false
    for hh <= tt {
        x, y := q[hh].first, q[hh].second
        hh += 1
        for i := 0; i < 4; i++ {
            nx, ny := x+dx[i], y+dy[i]
            if nx >= 1 && nx <= n && ny >= 1 && ny <= m && dist[nx][ny] >= mid && !vis[nx][ny] {
                vis[nx][ny] = true
                tt += 1
                q[tt] = pair{nx, ny}
                if nx == tx && ny == ty {
                    isFind = true
                    break
                }
            }
        }
        // 如果找到一条路径，提前退出，避免后续多余的搜索
        if isFind {
            break
        }
    }
​
    ans := vis[tx][ty]
    // 将到达过的点全部标记为空，方便下一次遍历，无需清空整个数组
    for i := 0; i <= tt; i++ {
        vis[q[i].first][q[i].second] = false
    }
    return ans
}
​
func main() {
    in := bufio.NewReader(os.Stdin)
    fmt.Fscan(in, &n)
    fmt.Fscan(in, &m)
    fmt.Fscan(in, &k)
​
    for i := 1; i <= n; i++ {
        for j := 1; j <= m; j++ {
            dist[i][j] = INF
        }
    }
​
    hh, tt := 0, -1
    for a := 1; a <= k; a++ {
        var x, y int
        fmt.Fscan(in, &x)
        fmt.Fscan(in, &y)
        dist[x][y] = 0
        tt += 1
        q[tt] = pair{x, y}
    }
​
    for hh <= tt {
        x, y := q[hh].first, q[hh].second
        hh += 1
        for i := 0; i < 4; i++ {
            nx, ny := x+dx[i], y+dy[i]
            if nx >= 1 && nx <= n && ny >= 1 && ny <= m && dist[nx][ny] > dist[x][y]+1 {
                dist[nx][ny] = dist[x][y] + 1
                tt += 1
                q[tt] = pair{nx, ny}
            }
        }
    }
​
    fmt.Fscan(in, &sx)
    fmt.Fscan(in, &sy)
    fmt.Fscan(in, &tx)
    fmt.Fscan(in, &ty)
​
    // 二分答案，最大为 min(dist[sx][sy], dist[tx][ty])
    l, r := 0, min(dist[sx][sy], dist[tx][ty])
    for l < r {
        mid := (l + r + 1) >> 1
        if check(mid) {
            l = mid
        } else {
            r = mid - 1
        }
    }
​
    fmt.Println(l)
}
​
func min(x, y int) int {
    if x < y {
        return x
    }
    return y
}

Js

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
    return;
});
process.stdin.on('end', () => {
    const lines = input.trim().split('\n');
    const N = 510;
    const INF = 0x3f3f3f3f;
    let g = [];
    let dist = [];
    let vis = [];
    let q = [];
    let n, m, k;
    let sx, sy, tx, ty;
​
    let dx = [-1, 0, 1, 0];
    let dy = [0, 1, 0, -1];
​
    // check 即按照 mid 这个最近距离，任何到任意一个点的距离小于 mid 的点都不可到达
    function check(mid) {
        let hh = 0, tt = -1;
        q[++tt] = [sx, sy];
        vis[sx][sy] = true;
        let isFind = false;
        while (hh <= tt) {
            let [x, y] = q[hh];
            hh += 1;
            for (let i = 0; i < 4; ++i) {
                let nx = x + dx[i], ny = y + dy[i];
                if (nx >= 1 && nx <= n && ny >= 1 && ny <= m && dist[nx][ny] >= mid && !vis[nx][ny]) {
                    vis[nx][ny] = true;
                    q[++tt] = [nx, ny];
                    if (nx == tx && ny == ty) {
                        isFind = true;
                        break;
                    }
                }
            }
            // 如果找到一条路径，提前退出，避免后续多余的搜索
            if (isFind) break;
        }
​
        let ans = vis[tx][ty];
        // 将到达过的点全部标记为空，方便下一次遍历，无需清空整个数组
        for (let i = 0; i <= tt; ++i) vis[q[i][0]][q[i][1]] = false;
        return ans;
    }
​
    nmk = lines[0].split(' ').map(Number);
    n = nmk[0], m = nmk[1], k = nmk[2];
​
    for (let i = 1; i <= n; ++i) {
        g[i] = new Array(m + 1).fill(0);
        dist[i] = new Array(m + 1).fill(INF);
        vis[i] = new Array(m + 1).fill(false);
    }
​
    let hh = 0, tt = -1;
    for (let a = 1; a <= k; ++a) {
        let [x, y] = lines[a].split(' ').map(Number);
        dist[x][y] = 0;
        q[++tt] = [x, y];
    }
​
    while (hh <= tt) {
        let [x, y] = q[hh];
        hh += 1;
        for (let i = 0; i < 4; ++i) {
            let nx = x + dx[i], ny = y + dy[i];
            if (nx >= 1 && nx <= n && ny >= 1 && ny <= m && dist[nx][ny] > dist[x][y] + 1) {
                dist[nx][ny] = dist[x][y] + 1;
                q[++tt] = [nx, ny];
            }
        }
    }
​
    [sx, sy, tx, ty] = lines[lines.length - 1].split(' ').map(Number);
​
    // 二分答案，最大为 min(dist[sx][sy], dist[tx][ty])
    let l = 0, r = Math.min(dist[sx][sy], dist[tx][ty]);
    while (l < r) {
        let mid = (l + r + 1) >> 1;
        if (check(mid)) l = mid;
        else r = mid - 1;
    }
​
    console.log(l);
});

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

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

相关文章

lua中chunk的理解

lua中chunk的理解

在Lua中&#xff0c;一个chunk是一段可执行的Lua代码。通常&#xff0c;一个chunk由一系列语句和表达式组成&#xff0c;可以是一个完整的程序文件&#xff0c;也可以是一个交互式控制台中输入的一行代码。 例如&#xff0c;下面是一个简单的Lua chunk&#xff1a; print(&qu…
阅读更多...
阿里巴巴最新30万字1008道Java经典面试题总结(附答案)限时开源

阿里巴巴最新30万字1008道Java经典面试题总结(附答案)限时开源

前言 在备战面试的时候&#xff0c;大家总会通过刷题的方式来准备&#xff0c;然而刷题是有用没错&#xff0c;有时候还得看看押题能不能压中重点&#xff0c;大厂喜欢问些什么技术点&#xff0c;不然当那个笑眯眯的面试官问出那些你再熟悉不过的问题 Java 问题时&#xff0c;…
阅读更多...
vue2.x项目引入CKEditor4的两种方式

vue2.x项目引入CKEditor4的两种方式

百度用了不行的看过来&#xff0c;本文专治各种流程不通的 一.直接npm下载型 下载ckeditor到vue项目 npm install ckeditor4-vue2.在main.js里导入 import Vue from vue; import CKEditor from ckeditor4-vue;Vue.use( CKEditor );3.在需要使用的组件里这样使用 <templ…
阅读更多...
day54_spring整合mybatis

day54_spring整合mybatis

SpringMybatis整合【重点】 Spring学完了,主要学习Spring两个内容:IOCAOP 利用这两个知识来完成spring和mybatis的整合 IOC: 控制反转,用来创建对象 XxxService通过数据源创建数据库连接创建SqlSessionFactory创建SqlSession获得XxxMapper代理对象 AOP: 面向切面 控制事务 具体…
阅读更多...
基于spring的前后端一体化积分商城系统

基于spring的前后端一体化积分商城系统

系统介绍 积分商城系统是一个基于Spring、MySQL和Redis等技术栈构建的全功能商城解决方案。该系统旨在为用户提供一个便捷的购物体验&#xff0c;并以积分作为支付和奖励的核心机制。 系统的核心功能包括商品浏览、购买下单、积分管理和订单处理。用户可以通过客户端访问系统…
阅读更多...
一业余无线电爱好者因违规被罚2.4万美元，是否合理？

一业余无线电爱好者因违规被罚2.4万美元，是否合理？

据一份名为《关于处罚款项的通知》&#xff0c;美国联邦通信委员会经过调查&#xff0c;对加利福尼亚州的一名业余无线电持有人菲利普J博代特&#xff08;业余电台呼号&#xff1a;N6PJB&#xff09;&#xff0c;处以巨额罚款&#xff0c;罚款金额为2.4万美元&#xff0c;折合人…
阅读更多...
颠覆2D对象检测模型，MediaPipe 3D对象检测还原真实的对象特征

颠覆2D对象检测模型，MediaPipe 3D对象检测还原真实的对象特征

关于对象检测，我们以前分享的文章都是介绍的2D的对象检测，但是我们很多使用场景下，希望检测到的对象能够以3D的影像呈现出来，本期介绍的MediaPipe Objectron便是是用于日常对象的移动实时3D对象检测解决方案。它检测2D图像中的对象，并通过在Objectron数据集上训练的机器学…
阅读更多...
6.17黄金反弹是否到顶，下周开盘如何布局

6.17黄金反弹是否到顶，下周开盘如何布局

近期有哪些消息面影响黄金走势&#xff1f;下周黄金多空该如何研判&#xff1f; ​黄金消息面解析&#xff1a;黄金周五(6月16日)小幅收高&#xff0c;但在触及5月以来最低盘中水准后本周以下跌收官。美市尾盘&#xff0c;现货黄金收报1957.68美元/盎司&#xff0c;下跌0.19美…
阅读更多...
干货|来自新加坡管理大学、KAUST的大模型最新进展：推荐系统、未来AI社会研究……...

干货|来自新加坡管理大学、KAUST的大模型最新进展：推荐系统、未来AI社会研究……...

点击蓝字 关注我们 AI TIME欢迎每一位AI爱好者的加入&#xff01; ChatGPT的横空出世刷新了我们对这个世界的认知和想象&#xff0c;而大型语言模型也逐渐成为学术界的研究热点。在自然语言处理、智能推荐、知识获取、智能对话等领域&#xff0c;大模型发挥着越来越重要的作用。…
阅读更多...
自然语言处理从入门到应用——词向量的评价方法

自然语言处理从入门到应用——词向量的评价方法

分类目录&#xff1a;《自然语言处理从入门到应用》总目录 对于不同的学习方法得到的词向量&#xff0c;通常可以根据其对词义相关性或者类比推理性的表达能力进行评价&#xff0c;这种方式属于内部任务评价方法&#xff08;Intrinsic Evaluation&#xff09;。在实际任务中&am…
阅读更多...
Linux学习[15]bash学习深入1---bash的功能---变量详解

Linux学习[15]bash学习深入1---bash的功能---变量详解

文章目录 前言&#xff1a;1. bash功能2. 变量2.1 变量赋值2.2 unset取消变量2.3 环境变量 总结 前言&#xff1a; 之前在学树莓派相关内容的时候&#xff0c;对bash脚本的简单上手做了一个总结&#xff0c;并且归纳到下面三个博客。 当时参考的书为《从树莓派开始玩转linux》…
阅读更多...
Gitlab CI/CD入门（一）Python项目的CI演示

Gitlab CI/CD入门（一）Python项目的CI演示

本文将介绍CI/CD的基本概念&#xff0c;以及如何使用Gitlab来实现CI/CD。   本文介绍的CI/CD项目为个人Gitlab项目&#xff1a;gitlab_ci_test&#xff0c;访问网址为&#xff1a;https://gitlab.com/jclian91/gitlab_ci_test。 CI/CD的含义 在现代软件工程中&#xff0c;CI…
阅读更多...
【主跑例子】 Framework01、02；QFramework00（我跟着视频的旧版本，但推荐用最新的）、01（无）、02（无）、03（无）

【主跑例子】 Framework01、02；QFramework00（我跟着视频的旧版本，但推荐用最新的）、01（无）、02（无）、03（无）

总体介绍 做的是 00,10,13&#xff0c;考虑做10。 11,12没下载&#xff0c;当时把这两个误认为 00,10 用到了UniRx Framework有2个 00 Unity 游戏框架搭建 2019 第一季 C# 核心知识与简易 Manager Of Managers 框架搭建 120课数 01 Unity 游戏框架搭建 2019 第二季 模块/系统…
阅读更多...
前端Vue仿滴滴打车百度地图定位查找附近出租车或门店信息(更新版)

前端Vue仿滴滴打车百度地图定位查找附近出租车或门店信息(更新版)

前端vue仿滴滴打车百度地图定位查找附近出租车或门店信息, 下载完整代码请访问uni-app插件市场地址:https://ext.dcloud.net.cn/plugin?id12982 效果图如下: # #### 使用方法 使用方法 <!-- 官方文档&#xff1a; https://dafrok.github.io/vue-baidu-map/#/zh/start/b…
阅读更多...
五子棋：起源、原理与游戏规则、vue实现五子棋案例游戏

五子棋：起源、原理与游戏规则、vue实现五子棋案例游戏

目录&#xff1a; 引言五子棋的历史背景五子棋的原理五子棋的游戏规则五子棋游戏的实现 5.1 创建 Vue 组件 5.2 初始化棋盘 5.3 下棋与判断胜负 5.4 渲染棋盘与棋子总结 更多知识 学习&#xff1a;https://www.processon.com/view/60504b5ff346fb348a93b4fa#map 引言 五子棋…
阅读更多...
解密大型语言模型：从相关性中发现因果关系？

解密大型语言模型：从相关性中发现因果关系？

深度学习自然语言处理 原创作者&#xff1a;wkk 因果推理是人类智力的标志之一。因果关系NLP领域近年来引起了人们的极大兴趣&#xff0c;但其主要依赖于从常识知识中发现因果关系。本研究提出了一个基准数据集(CORR2CAUSE)来测试大语言模型(LLM)的纯因果推理能力。其中CORR2CA…
阅读更多...
I/O体系结构和设备驱动程序（一）

I/O体系结构和设备驱动程序（一）

I/O体系结构 让信息在CPU、RAM和I/O设备之间流动的数据通路称之为总线&#xff0c;即计算机内的主通信通道。所有计算机都有一条系统总线&#xff08;一种典型的系统总线是PCI总线&#xff09;&#xff0c;连接内部大部分的硬件设备。计算机内不同的总线可以通过“桥”进行连接…
阅读更多...
lua语言的闭包设计和LClosure解读

lua语言的闭包设计和LClosure解读

什么是闭包 闭包是一种特殊的函数&#xff0c;它可以访问其创建时所处的环境中的变量&#xff0c;即使在函数创建后&#xff0c;环境已经不再存在&#xff0c;这些变量仍然可以被访问。 为了更好地理解闭包&#xff0c;我们可以看一个例子&#xff1a; function counter()lo…
阅读更多...
关于路由,浏览器监听popstate事件，当你点前一个页面按钮时，会触发这个popstate事件

关于路由,浏览器监听popstate事件，当你点前一个页面按钮时，会触发这个popstate事件

阅读更多...
Appium知多少

Appium知多少

Appium我想大家都不陌生&#xff0c;这是主流的移动自动化工具&#xff0c;但你对它真的了解么&#xff1f;为什么很多同学搭建环境时碰到各种问题也而不知该如何解决。 appium为什么英语词典查不到中文含义&#xff1f; appium是一个合成词&#xff0c;分别取自“applicatio…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023