研究生算法课程笔记

已于 2022-12-05 20:21:38 修改
阅读量622 收藏
点赞数
分类专栏： 算法 文章标签： 算法 java 蓝桥杯
于 2022-11-19 10:22:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43364551/article/details/127933301
版权

文章目录

1.1、最长合法区间

题目

在这里插入图片描述

题解

C语言代码

#include<stdio.h>
#include<stdlib.h>

int max(int a, int b) {
	return a > b ? a : b;
}

int main() {
	int n;
	scanf("%d", &n);
	int *arr = (int *)malloc(n * sizeof(int));
	int flags[100000];
	int i = 0;
	for (i = 0; i < n; i ++) {
		scanf("%d", &arr[i]);
	}
	
	i = 0;
	int j = 1;
	int maxIntervel = 1;
	int count = 1;
	flags[arr[i]] = 1;
	int iNum, jNum;
	while (j < n) {
		jNum = arr[j];
		flags[jNum] ++;
		if (flags[jNum] == 1) {
			count ++;
			while (count > 2) {
				iNum = arr[i];
				flags[iNum] --;
				if (flags[iNum] == 0) {
					count --;
				}
				i ++;
			}
		}
		maxIntervel = max(maxIntervel, j - i + 1);
		j ++;
	}
	
	printf("%d", maxIntervel);
	return 0;
}

Java代码
评判机制问题，同一解法，JAVA只能得8分，提示内存超出限制

import java.util.Scanner;

/**
 * 最长合法区间
 */
public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] numbers = new int[n];
        for (int i = 0; i < n; i++) {
            numbers[i] = in.nextInt();
        }

        int[] flags = new int[100000];
        int count = 1;
        int maxInterval = 1;
        int i = 0, j = 1;
        flags[numbers[0]] = 1;
        while (j < n) {
            int num = numbers[j];
            flags[num] ++;
            if (flags[num] == 1) {
                count ++;
                while (count > 2) {
                    int iNum = numbers[i];
                    flags[iNum] --;
                    if (flags[iNum] == 0) {
                        count --;
                    }
                    i ++;
                }
            }
            maxInterval = Math.max(maxInterval, j - i + 1);
            j ++;
        }
        System.out.println(maxInterval);
    }
}

1.2、Ahpelios会数数

题目

在这里插入图片描述

题解

C代码

#include<stdio.h>
int map[10] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};
int countNum(int num) {
	if (num == 0) {
		return map[0];
	}
	int sum = 0;
	while (num > 0) {
		sum += map[num % 10];
		num /= 10;
	}
	return sum;
}

int main() {
	int n, i;
	long res = 0;
	scanf("%d", &n);
	for (i = 0; i <= n; i ++) {
		res += countNum(i);
	}
	
	printf("%d", res);
	return 0;
}

Java代码

import java.util.Scanner;

public class Main {
    public static int[] map = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        long res = 0;
        for (int i = 0; i <= n; i++) {
            res += dealNumStr(String.valueOf(i));
        }
        System.out.println(res);
    }


    public static int dealNumStr(String numStr) {
        int total = 0;
        for (int i = 0; i < numStr.length(); i++) {
            String s = numStr.substring(i, i + 1);
            total += map[Integer.parseInt(s)];
        }
        return total;
    }
}

1.3、kstring

题目

在这里插入图片描述

题解

C++代码
评优代码只有6分

#include <bits/stdc++.h>

using namespace std;

int main()
{
	int k;
	string input;
	cin>>input>>k;
	int len = input.size()-k+1;
	for(int a=0; a<26; a++) {
		multimap<string,int> node;
		for(int i=0; i<len; i++) {
			char head = input[i];
			if(head == (char)(a+'a'))
				node.insert(pair<string,int>(input.substr(i,k),i+1));
		}
		if(!node.size()) continue;
		multimap <string,int>::iterator it ;
		for(it= node.begin(); it!=node.end(); ++it) {
			printf("%d ",it->second);
		}
		node.clear();
	}
	return 0;
}

Java代码
5分

import java.util.*;

/**
 * kstring
 */
public class Q1_Kstring {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.next();
        int k = in.nextInt();
        TreeMap<String, Integer> treeMap = new TreeMap<>();
        for (int i = 0; i < 26; i++) {
            treeMap.clear();
            for (int j = 0; j <= s.length() - k; j++) {
                if (s.charAt(j) == 'a' + i) {
                    // 字符串最后加上j是为了避免TreeMap键值相同时的覆盖操作
                    treeMap.put(s.substring(j, j + k) + j, j + 1);
                }
            }
            if (treeMap.size() > 0) {
                for (Map.Entry<String, Integer> entry : treeMap.entrySet()) {
                    System.out.print(entry.getValue() + " ");
                }
            }
         }
    }
}

1.4、杰哥与数字

题目

在这里插入图片描述

题解

Java代码10分

import java.util.Scanner;

public class Q1_JacksonNumber {
    /*
     * 记录n是否存在某个数字
     */
    static boolean[] bits = new boolean[10];
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        // 初始化bits
        int temp = n;
        while (temp > 0) {
            bits[temp%10] = true;
            temp /= 10;
        }

        int count = 0;
        for (int i = 1; i * i <= n; i ++) {
            if (n % i != 0) {
                continue;
            }
            int b = n/i;
            if (i == b) {
                if (hasSameBit(i)) {
                    count ++;
                }
            } else {
                if (hasSameBit(i)) {
                    count ++;
                }
                if (hasSameBit(b)) {
                    count ++;
                }
            }
        }

        System.out.println(count);
    }

    public static boolean hasSameBit(int num) {
        while (num > 0) {
            if (bits[num%10]) {
                return true;
            }
            num /= 10;
        }
        return false;
    }
}

2.1、杰哥和序列

题目

在这里插入图片描述

题解

Java代码8分，内存超出限制

import java.util.Scanner;

/**
 * 杰哥和序列
 */
public class Q2_1 {
    public static int[] nums;
    public static int[] temp;
    public static int res = 0;
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int a = in.nextInt();
        int b = in.nextInt();
        nums = new int[n];
        temp = new int[n];
        for (int i = 0; i < n; i++) {
            nums[i] = in.nextInt();
        }
        countInversionPair(0, nums.length - 1);
        System.out.println(Math.min(a, b) * res);
    }

	// 计算数组中逆序对个数
    public static void countInversionPair(int left, int right) {
        if (left < right) {
            int mid = left + (right - left)/2;
            countInversionPair(left, mid);
            countInversionPair(mid + 1, right);

            int begin = mid;
            int end = right;
            int index = end;
            while (index >= left) {
                if (nums[begin] > nums[end]) {
                    res += end - mid;
                    temp[index --] = nums[begin --];
                } else {
                    temp[index --] = nums[end --];
                }
                if (begin == left - 1) {
                    while (index != left - 1) {
                        temp[index --] = nums[end --];
                    }
                }
                if (end == mid) {
                    while (index != left - 1) {
                        temp[index --] = nums[begin --];
                    }
                }
            }

            for (int i = left; i <= right; i++) {
                nums[i] = temp[i];
            }

        }

    }

}

C++代码10分

#include<bits/stdc++.h>
#define ll long long
#define N 100000+9

using namespace std;

int n, nums[N], temp[N];
ll a,b,num=0;

void countInversionPair(int l,int r){
    if( l!=r ){
        int mid=(l+r)>>1;
        countInversionPair(l,mid);
        countInversionPair(mid+1,r);
        int index=r,begin=mid,end=r;
        while( index>=l ){
            if( nums[begin]>nums[end] ){
                num+=(end-mid);
                temp[index--]=nums[begin--];
            }
            else
                temp[index--]=nums[end--];
            if( begin==l-1 ) while( index!=l-1 ) temp[index--]=nums[end--];
            if( end==mid ) while( index!=l-1 ) temp[index--]=nums[begin--];
        }
        for( int i=l ; i<=r ; i++ ) nums[i]=temp[i];
    }
}

int main()
{
    scanf("%d %lld %lld",&n,&a,&b);
    for( int i=1 ; i<=n ; i++ ) scanf("%d",&nums[i]);
    a=min(a,b);
    countInversionPair(1,n);
    printf("%lld",num*a);
    return 0;
}

2.2、YY and Lucky Number

题目

在这里插入图片描述

题解

C++代码9分

#include <bits/stdc++.h>

using namespace std;

int cache[10] = {0, 9, 99, 351, 927, 2151, 4671, 9783, 20079, 40743};
int digest[11] = {0, 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000,1000000000};
int bitSet[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

int onlyTwoNum(int num) {
	if (num == 0) {
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i ++) {
		bitSet[i] = 0;
	}
	int count = 0;
	while (num > 0) {
		int b = num % 10;
		if (bitSet[b] == 0) {
			bitSet[b] = 1;
			count ++;
		}
		num /= 10;
	}
	return count <= 2;
}

long luckyNumber(long num, int length) {
	// 获取最高位
	int topDigit = num / digest[length];
	// length - 1 位下的luckyNum的数目 和 枚举所有最高位的luckyNum的数目
	// 若num = 51458 那么，现在只需要统计 5xxxx 中luckyNum的数目
	long res = cache[length - 1] + (cache[length] - cache[length - 1]) / 9 * (topDigit - 1);
	for (int i = topDigit * digest[length]; i <= num; i++) {
		if (onlyTwoNum(i)) {
			res ++;
		}
	}
	return res;
}

int main()
{
	long n;
	cin>>n;
	int length = 0, temp = n;
	while (temp > 0) {
		temp /= 10;
		length ++;
	}
	int res;
	if (n == 1000000000) {
		res = cache[9] + 1;
	} else {
		res = luckyNumber(n, length);
	}
	cout<<res;
	return 0;
}

Java代码8分

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Main {
    public static int[] cache = {0, 9, 99, 351, 927, 2151, 4671, 9783, 20079, 40743};
    public static int[] digest = {0, 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};
    public static Set<Integer> bitSet = new HashSet<>();

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int res;
        if (n == 1000000000) {
            res = cache[9] + 1;
        } else {
            res = luckyNumber(n);
        }
        System.out.println(res);
    }

    public static int luckyNumber(int num) {
        // 获取位数
        int length = String.valueOf(num).length();
        // 获取最高位
        int topDigit = num / digest[length];
        // length - 1 位下的luckyNum的数目 和 枚举所有最高位的luckyNum的数目
        // 若num = 51458 那么，现在只需要统计 5xxxx 中luckyNum的数目
        int res = cache[length - 1] + (cache[length] - cache[length - 1]) / 9 * (topDigit - 1);


        for (int i = topDigit * digest[length]; i <= num; i++) {
            if (onlyTwoNum(i)) {
                res ++;
            }
        }
        return res;
    }

    public static boolean onlyTwoNum(int num) {
        if (num == 0) {
            return true;
        }
        bitSet.clear();
        while (num > 0) {
            bitSet.add(num % 10);
            num /= 10;
        }
        return bitSet.size() <= 2;
    }

}

2.3、YY and One

题目

题解

Java代码10分

import java.util.Scanner;

public class Main {
    public static long[] oneNum = {0, 1, 11, 111, 1111, 11111, 111111, 1111111, 11111111, 111111111, 1111111111, 11111111111L, 111111111111L, 1111111111111L, 11111111111111L};
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long n = in.nextLong();
        System.out.println(oneTotal(n));
    }

    public static long oneTotal(long num) {
        num = Math.abs(num);
        if (num == 0) {
            return 0;
        }

        int length = String.valueOf(num).length();
        long res1 = Math.abs(num - oneNum[length]);
        long res2 = Math.abs(num - oneNum[length + 1]);

        // 判断xxxx与1111和11111哪个更接近
        if (res1 < res2) {
            return length + oneTotal(res1);
        } else {
            return length + 1 + oneTotal(res2);
        }
    }

}

C++代码10分

#include <bits/stdc++.h>
using namespace std;
long long oneNum[15] = {0, 1, 11, 111, 1111, 11111, 111111, 1111111, 11111111, 111111111, 1111111111, 11111111111, 111111111111, 1111111111111, 11111111111111};

long long mathAbs(long long num) {
    return num < 0 ? -num : num;
}

int getLength(long long num) {
    int len = 0;
    while (num > 0) {
        len ++;
        num /= 10;
    }
    return len;
}

long long oneTotal(long long num) {
	num = mathAbs(num);
	if (num == 0) {
		return 0;
	}

	int length = getLength(num);
	long long res1 = mathAbs(num - oneNum[length]);
	long long res2 = mathAbs(num - oneNum[length + 1]);

	// 判断xxxx与1111和11111哪个更接近
	if (res1 < res2) {
		return length + oneTotal(res1);
	} else {
		return length + 1 + oneTotal(res2);
	}
}

int main()
{
	long long n;
	cin >> n;

	cout << oneTotal(n) << endl;
	return 0;
}
it00zyq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
算法设计与分析（研究生课程）总结 附Java实现
weixin_38098551的博客
12-06 1069
递归问题 讲一个大型问题转化为与原问题类似的小问题来解决 全排列问题 //全排列 public static void fullSort(int[] arr,int k,int m){ if(k==m){ for(int i=0;i<=m;i++){ System.out.print(arr[i]); ...
研究生课程 算法分析-贪心法
张小彬的专栏
12-31 1104
贪心法的思想在求解一些最优化问题的时候，一般会分成多个步骤，每一步都有一个选择。贪心算法的思想在于，先不从整体考虑，每次都只做当前看来最优的思想，即局部最优解，期望通过一步步的局部最优解，最后构造出全局最优解。贪心算法是很多问题的最优解，当然也有很多问题只是局部最优，或者近似最优解，在构造贪心算法的时候，要注意贪心选择是否能求出最后的最优解。贪心算法的基本要素最优子结构性质一个问题的最优解包含其子问
研究生课程 算法分析-动态规划
张小彬的专栏
12-29 656
动态规划的思想上一篇博文讲了分治法，这一篇的动态规划思想有些接近，但是两者最大区别是，动态规划要解决的子问题往往不是独立的，子问题往往被重复求解了很多次。所以一个叫朴素的想法是，把每个子问题的答案都保存下来，从而避免大量的重复计算。这种方法叫做备忘录方法，是典型的以空间换取时间。动态规划的基本要素最优子结构性质最优子结构的性质指的是，问题的最优解包含着其子问题的最优解。利用该性质，自底向上递归地从子
研究生课程 算法分析-分治法
张小彬的专栏
12-29 779
分治法（divide and conquer）是算法分析里比较直观和朴素的思想，应用也很广泛。分治法的思想分治法的思想是，把一个复杂的问题 P 划分称 kk 个子问题，这些子问题相互独立且与原问题相同。递归调用子问题，直到问题规模足够小，可以很容易地求解为止；接着，把小规模的问题的解合并成一个更大规模的问题的解。可以用下面的伪代码来描述，divide-and-conquer(P) { if
南开大学软件学院2021年秋季学期研究生算法课程（复习）
Ritannn的博客
12-19 353
为什么要学习算法？ 在有限时间和内存下，编写程序正确地或有效地解决问题。 计算Fibonacci数列的第n项 算法一：递归函数 int F(int n){ if(n<=2) return 1; return F(n-1)+F(n-2); } 算法二：递推循环 int F(int n){ if(n<=2) return 1; int f1=1, f2=1; for(int i=3;i<=n;i++){ int temp
期末必备研究生课程-数值分析笔记
最新发布
06-20
通过Python或MATLAB等编这份数值分析笔记适合数学、工程、计算机科学及相关领域的学生和研究人员，旨在帮助他们掌握和应用数值方法解决实际问题的能力。程语言实现数值方法，并提供了实际案例和代码示例，帮助读者...
数据结构笔记 绪论+算法.docx
12-31
《数据结构笔记 绪论+算法》是对B站王卓教授数据结构课程的整理，结合了PPT和教材内容，适合考研复习使用。笔记中包含了数据结构的基础概念和算法的相关知识。 1. 数据和数据元素： 数据是描述现实世界事物的符号，...
MIT算法导论公开课之课程笔记 课程简介及算法分析.rar
07-06
以上就是《MIT算法导论公开课之课程笔记 课程简介及算法分析》的主要内容，这份资料旨在帮助学习者系统地理解和掌握算法设计与分析的核心概念，为他们未来在计算机科学领域的深入研究打下坚实基础。通过深入学习这些...
算法导论 黑皮书 期末复习笔记
01-10
这本书被广泛用作大学本科和研究生课程的教材，同时也是许多专业人士自我提升的首选读物。期末复习笔记通常会涵盖书中的核心概念、重要算法以及解题策略，帮助学生更好地理解和掌握这些知识。 在《算法导论》中，...
研究生复试个人自述PPT课件
03-28
- 完成了以峨眉山实地考察为代表的自然地理学习，以及通过Dijkstra算法实现的数字化垃圾调度系统的课题研究，展示了科研和实际应用的结合。 - 参与华北地区秸秆燃烧的卫星遥感监测项目，利用Calipso卫星和轨迹模拟...
研究生算法课—递归
10-01
本文包括数组的妙用 递归算法的讲解与应用 生成函数 特征方程等 运用大量例题论证
研究生课程 数论算法讲义（word版）
09-18
研究生课程，数论算法，希望给大家的学习有所帮助！
MIT的高级算法课程 研究生和博士们好好学习吧
11-23
MIT的高级算法课程 研究生和博士们好好学习吧 流网络等 很好很强大
南开大学软件学院2021年秋季学期研究生算法课程（复习）非确定算法：随机与近似
Ritannn的博客
12-25 781
非确定算法：随机与近似 确定性算法Deterministic algorithms 对于给定的输入，算法的输出和运行时间不变 非确定性算法Non-deterministic algorithms 对于给定的输入，算法的输出或运行时间是不确定的 启发式算法Heuristic algorithms 利用输入数据的特征和信息对问题进行求解 尽全力逼近最优解，但是无法得知和最优解的差距 近似算法Approximation algorithms 对问题给出一个近似最优解（数据无关） 可以
研究生必会算法
天河水
07-11 1326
<br />1。广义表转换二叉树<br />2。用后续遍历计算树高度和节点个数
机器学习必学10大算法
weixin_30505751的博客
03-19 571
1. 线性回归 在统计学和机器学习领域，线性回归可能是最广为人知也最易理解的算法之一。 预测建模主要关注的是在牺牲可解释性的情况下，尽可能最小化模型误差或做出最准确的预测。我们将借鉴、重用来自许多其它领域的算法（包括统计学）来实现这些目标。 线性回归模型被表示为一个方程式，它为输入变量找到特定的权重（即系数 B），进而描述一条最佳拟合了输入变量（x）和输出变量（y）之间关系的直线。 线性回...
计算机专业考研复试上机算法学习
theworld666的博客
04-03 5839
计算机考研复试上机算法刷题
应届硕士研究生算法岗秋招总结
Aiur的博客
10-26 1018
文章目录写在前面一、投递二、笔试情况算法岗开发岗三、面试自我介绍项目经历个人情况总结 写在前面 从七月的提前批开始，一直熬到现在，终于上岸，其中的辛酸、焦虑已经不想再回首。 距离上一篇已经过去了好久，原本计划的内容也早已被太多太多的事情挤到根本想不起来，趁着签过offer后难得的空闲时间，对这段时间的笔试面试做一个总结，希望能给同方向的朋友提供一点点参考 一、投递 题主的研究方向是NLP中的知识图谱（KG），由于主要使用深度学习方法因此也考虑这方面的职位，同时由于学过一段时间前端开发以及做过全栈开发的
1.2杰哥和数字
weixin_30851867的博客
11-30 606
题目 题意：求一个数字的因子中，有多少个因子，是符合与原数字有相同数字的数的 思路：先把原数字拆开，村在数组里，写一个判断的函数，输入一个数字，就可以返回和原来的数字是不是有相同数字。在for一边，从1到根号n，看看有哪些是n的因子，然后这样看的时候，也看看另一个因子是不是符合条件，注意，比如输入100，它的因子有10*10，这时候如果两个因子相同就只要判断一次就好了 #include...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

it00zyq

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值