2025年杭州电子科技大学计算机考研复试机试真题

2025年杭州电子科技大学计算机考研复试上机真题

历年杭州电子科技大学计算机考研复试上机真题

历年杭州电子科技大学计算机考研复试机试真题

更多学校完整题目开源地址：https://gitcode.com/u014339447/pgcode

百度一下pgcode 即可查看，输入 “学校名称” 即可筛选该校历年机试真题，包括真题、ac代码、解题思路、视频讲解。

死神来了-杭州电子科技大学

题目描述

有一天，王小子在遨游世界时，遇到了一场自然灾害。

一个人孤独的在一个岛上，没有吃的没有喝的。

在他饥寒交迫将要死亡时，死神来了。

由于这个死神在成神之前是一个数学家，所以他有一个习惯，会和即死之人玩一个数学游戏，来决定是否将其灵魂带走。

游戏规则是死神给王小子两个整数 $n$（$100\le n\le 1000000$）, $m$（$2\le m\le n$），在 $1$ ~ $n$ 个数中，随机取 $m$ 个数，问在这 $m$ 个数中是否一定存在一个数是另一个数的倍数，是则回答“YES", 否则”NO"。

如果王小子回答正确，将有再活下去的机会。

但是他很后悔以前没有好好学习数学，王小子知道你数学学得不错，请你救他一命。

输入格式

有多组测试数据，不多于 $10000$;

每组有两个数 $n$, $m$;

以文件结束符 $EOF$ 为结束标志。

输出格式

输出"YES"或"NO"。

输入样例

100 80
100 20

输出样例

YES
NO

#include <stdio.h>

int main() {
    int n, m;
    // 循环读取多组测试数据，直到EOF
    while (scanf("%d %d", &n, &m) != EOF) {
        // 计算1~n中奇数的个数
        int odd_count = (n + 1) / 2;
        if (m > odd_count) {
            printf("YES\n");
        } else {
            printf("NO\n");
        }
    }
    return 0;
}

字符串区间翻转-杭州电子科技大学

题目描述

小杭有一个由 $0$ 和 $1$ 组成的字符串

现在小杭有一次机会，可以选择一个任意的区间 $[L,R]$，将该区间内的所有字符串进行翻转（即 $0$ -> $1$, $1$ -> $0$）。

请问小杭经过一次翻转之后字符串中最多会有多少个 $1$？

输入格式

第一行输入一个正整数 $n$，表示字符串长度，$n<=10^7$。

接下来一行一个输入一个 $01$ 字符串。

可能有多组测试数据输入。

输出格式

输出题目要求的答案。

输入样例

4
1001

输出样例

4

import java.util.*;

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

        int n = in.nextInt();
        in.nextLine();
        String s = in.nextLine();

        int[] dp = new int[n];
        int res = 0;
        int cnt1 = 0;

        // 第 0 位
        if (s.charAt(0) == '0') dp[0] = 1;
        else {
            dp[0] = 0;
            cnt1++;
        }
        res = dp[0];

        for (int i = 1; i < n; i++) {
            if (s.charAt(i) == '0') {
                dp[i] = dp[i - 1] + 1;
            } else {
                dp[i] = Math.max(dp[i - 1] - 1, 0);
                cnt1++;
            }
            res = Math.max(res, dp[i]);
        }

        System.out.println(cnt1 + res);
    }
}

调查作弊-杭州电子科技大学

题目描述

学校 $icpc$ 举办了一场选拔赛，赛后由学长人工进行代码查重，学长们非常严谨，每当一个人发现学生 $a$ 和学生 $b$ 的代码相似，他就会进行上报并记录下来，如果 $a$ 和 $b$ 的代码相似，$b$ 和 $c$ 的代码相似，那么也认为 $a$ 和 $c$ 的代码相似，而只有当上报的学生 $a$, $b$ 已经被记录为相似，才会被视作抄袭，如果 $a$ 和 $b$ 互相抄袭，$b$ 和 $c$ 互相抄袭，那么也认为 $a$ 和 $c$ 互相抄袭。

如果几个人互相抄袭，我们称这几个人为 $作弊团伙$，现在已经知道了每条被上传的数据，而你想知道我们学校有多少个其他的 $作弊团伙$ ( 其他表示不包括自己的 $作弊团伙$，视个人情况判断是否将答案减 $1$ )

输入格式

第一行输入两个数字 $n$ 和 $m$ $(2\le n,m\le 1e6)$，表示 $gzu$ 的人数和上传记录的条数

接下来的 $m$ 行每行输入两个数字 $a$, $b$ $(1\le a,b\le n)$ 表示发现 $a$ 和 $b$ 互相抄袭

输出格式

输出一个数字，表示 $作弊团伙$ 的个数

输入样例

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

输出样例

2

#include <iostream>
#include <set>
#include <vector>
using namespace std;
int main() {
    int n=0,m=0,sum=1,a=0,b=0,flag=0;
    cin>>n>>m;
    set<int> sets[10]; 
    
    while(cin>>a>>b){
        flag=0;
        for(int j=0;j<sum;j++)
        {
            
        if(sets[j].count(b))
        {
            sets[j].insert(a);
            flag=1;
            break;
        }else if(sets[j].count(a))
        {
            sets[j].insert(b);
            flag=1;
            break;
        }
        
        }
        if(flag!=1){
            sum++;
            sets[sum-1].insert(a);
            sets[sum-1].insert(b);
        }

    }
    cout<<sum-1;
    return 0;
}

胜利大逃亡-杭州电子科技大学

题目描述

Ignatius 再次被魔王抓走了(搞不懂他咋这么讨魔王喜欢)……

这次魔王汲取了上次的教训，把 Ignatius 关在一个 $n\times m$ 的地牢里，并在地牢的某些地方安装了带锁的门，钥匙藏在地牢另外的某些地方。

刚开始 Ignatius 被关在 $(sx,sy)$ 的位置，离开地牢的门在 $(ex,ey)$ 的位置。

Ignatius 每分钟只能从一个坐标走到相邻四个坐标中的其中一个。

魔王每 $t$ 分钟回地牢视察一次，若发现 Ignatius 不在原位置便把他拎回去。

经过若干次的尝试，Ignatius 已画出整个地牢的地图。

现在请你帮他计算能否再次成功逃亡。

只要在魔王下次视察之前走到出口就算离开地牢，如果魔王回来的时候刚好走到出口或还未到出口都算逃亡失败。

输入格式

每组测试数据的第一行有三个整数 $n$, $m$, $t$ $(2\le n,m\le 20,t>0)$。

接下来的 $n$ 行 $m$ 列为地牢的地图，其中包括:

• $.$ 代表路

• $\ast$ 代表墙

• $@$ 代表 Ignatius 的起始位置

• KaTeX parse error: Expected group after '^' at position 1: ^̲ 代表地牢的出口

• $A$-$J$ 代表带锁的门，对应的钥匙分别为 $a$-$j$

• $a$-$j$ 代表钥匙，对应的门分别为 $A$-$J$

每组测试数据之间有一个空行。

输出格式

针对每组测试数据，如果可以成功逃亡，请输出需要多少分钟才能离开，如果不能则输出 $-1$。

输入样例

4 5 17
@A.B.
a*.*.
*..*^
c..b*
4 5 16
@A.B.
a*.*.
*..*^
c..b*

输出样例

16
-1

#include <iostream>
#include <queue>
#include <cstring>
using namespace std;

struct Node {
    int x, y, step, keys;
};

int n, m, t;
char maze[25][25];
bool vis[25][25][1<<10]; // 第三维表示钥匙状态
int dir[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};

int bfs(int sx, int sy, int ex, int ey) {
    memset(vis, 0, sizeof(vis));
    queue<Node> q;
    q.push({sx, sy, 0, 0});
    vis[sx][sy][0] = true;
    
    while (!q.empty()) {
        Node cur = q.front();
        q.pop();
        
        // 如果到达终点且时间小于t
        if (cur.x == ex && cur.y == ey && cur.step < t) {
            return cur.step;
        }
        
        // 如果时间已经达到或超过t，跳过
        if (cur.step >= t) {
            continue;
        }
        
        for (int i = 0; i < 4; i++) {
            int nx = cur.x + dir[i][0];
            int ny = cur.y + dir[i][1];
            int new_keys = cur.keys;
            
            // 检查边界和墙壁
            if (nx < 0 || nx >= n || ny < 0 || ny >= m || maze[nx][ny] == '*') {
                continue;
            }
            
            char ch = maze[nx][ny];
            
            // 如果是门，检查是否有对应钥匙
            if (ch >= 'A' && ch <= 'J') {
                int key_needed = 1 << (ch - 'A');
                if (!(cur.keys & key_needed)) {
                    continue; // 没有钥匙，不能通过
                }
            }
            
            // 如果是钥匙，更新钥匙状态
            if (ch >= 'a' && ch <= 'j') {
                new_keys = cur.keys | (1 << (ch - 'a'));
            }
            
            // 如果新状态没有被访问过
            if (!vis[nx][ny][new_keys]) {
                vis[nx][ny][new_keys] = true;
                q.push({nx, ny, cur.step + 1, new_keys});
            }
        }
    }
    
    return -1;
}

int main() {
    while (cin >> n >> m >> t) {
        int sx, sy, ex, ey;
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                cin >> maze[i][j];
                if (maze[i][j] == '@') {
                    sx = i;
                    sy = j;
                } else if (maze[i][j] == '^') {
                    ex = i;
                    ey = j;
                }
            }
        }
        
        int result = bfs(sx, sy, ex, ey);
        cout << result << endl;
        
        // 跳过空行
        char c;
        while ((c = cin.peek()) == '\n') {
            cin.get();
        }
    }
    
    return 0;
}

 } else if (maze[i][j] == '^') {
                ex = i;
                ey = j;
            }
        }
    }
    
    int result = bfs(sx, sy, ex, ey);
    cout << result << endl;
    
    // 跳过空行
    char c;
    while ((c = cin.peek()) == '\n') {
        cin.get();
    }
}

return 0;

}