研究生算法课程笔记

已于 2022-12-05 20:21:38 修改
阅读量625 收藏
点赞数
分类专栏： 算法 文章标签： 算法 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
    评论
专栏目录
南开大学软件学院2021年秋季学期研究生算法课程（复习）非确定算法：随机与近似
Ritannn的博客
12-25 784
非确定算法：随机与近似 确定性算法Deterministic algorithms 对于给定的输入，算法的输出和运行时间不变 非确定性算法Non-deterministic algorithms 对于给定的输入，算法的输出或运行时间是不确定的 启发式算法Heuristic algorithms 利用输入数据的特征和信息对问题进行求解 尽全力逼近最优解，但是无法得知和最优解的差距 近似算法Approximation algorithms 对问题给出一个近似最优解（数据无关） 可以
研究生课程 算法分析笔记
张小彬的专栏
12-29 1162
算法分析有四大经典的思想，分治法、贪心法、动态规划，最后一个是回溯法和分支限界法，后面会针对性都出一篇博客总结。这篇博文先总结一下除了四大算法之外的，杂七杂八的笔记。
1.2杰哥和数字
weixin_30851867的博客
11-30 606
题目 题意：求一个数字的因子中，有多少个因子，是符合与原数字有相同数字的数的 思路：先把原数字拆开，村在数组里，写一个判断的函数，输入一个数字，就可以返回和原来的数字是不是有相同数字。在for一边，从1到根号n，看看有哪些是n的因子，然后这样看的时候，也看看另一个因子是不是符合条件，注意，比如输入100，它的因子有10*10，这时候如果两个因子相同就只要判断一次就好了 #include...
ACM算法题之杰哥和数字
赴前尘
09-29 1643
★题目描述 杰哥特别喜欢和数字打交道，现在他有一个正整数X,他想知道有多少个满足要求的正整数D存在，要求是D是X的因子，并且D和X至少有一位相同。 ★输入格式 只有一行，一个正整数X。 对于30%的数据，X<=100。 对于50%的数据，X<=200。 对于100%的数据，X<=1000000000。 ★输出格式 只有一行，一个整数表示满足要求的数字D的个数。 ...
【02 杰哥与数字】
qq_44173144的博客
11-23 185
【代码】【02 杰哥与数字】
研究生课程 算法分析-动态规划
张小彬的专栏
12-29 656
动态规划的思想上一篇博文讲了分治法，这一篇的动态规划思想有些接近，但是两者最大区别是，动态规划要解决的子问题往往不是独立的，子问题往往被重复求解了很多次。所以一个叫朴素的想法是，把每个子问题的答案都保存下来，从而避免大量的重复计算。这种方法叫做备忘录方法，是典型的以空间换取时间。动态规划的基本要素最优子结构性质最优子结构的性质指的是，问题的最优解包含着其子问题的最优解。利用该性质，自底向上递归地从子
期末必备研究生课程-数值分析笔记
06-20
通过Python或MATLAB等编这份数值分析笔记适合数学、工程、计算机科学及相关领域的学生和研究人员，旨在帮助他们掌握和应用数值方法解决实际问题的能力。程语言实现数值方法，并提供了实际案例和代码示例，帮助读者...
数据结构笔记 绪论+算法.docx
12-31
《数据结构笔记 绪论+算法》是对B站王卓教授数据结构课程的整理，结合了PPT和教材内容，适合考研复习使用。笔记中包含了数据结构的基础概念和算法的相关知识。 1. 数据和数据元素： 数据是描述现实世界事物的符号，...
MIT算法导论公开课之课程笔记 课程简介及算法分析.rar
07-06
以上就是《MIT算法导论公开课之课程笔记 课程简介及算法分析》的主要内容，这份资料旨在帮助学习者系统地理解和掌握算法设计与分析的核心概念，为他们未来在计算机科学领域的深入研究打下坚实基础。通过深入学习这些...
算法笔记
04-02
- 在学习和研究算法的过程中，有许多有用的工具和资源可以帮助开发者更好地理解和掌握算法知识。 - Java相关的算法学习资源包括在线课程、书籍、博客文章等，例如《算法导论》、《Java算法教程》等都是很好的参考...
研究生课程 数论算法讲义（word版）
09-18
研究生课程，数论算法，希望给大家的学习有所帮助！
MIT的高级算法课程 研究生和博士们好好学习吧
11-23
MIT的高级算法课程 研究生和博士们好好学习吧 流网络等 很好很强大
研究生算法课—递归
10-01
本文包括数组的妙用 递归算法的讲解与应用 生成函数 特征方程等 运用大量例题论证
研究生课程矩阵分析课堂笔记，复习可看
最新发布
07-04
根据给定的信息，标题与描述均为“研究生课程矩阵分析课堂笔记，复习可看”，标签包括“课程资源”、“矩阵”及“矩阵分析”。虽然提供的部分内容似乎没有实质性的内容（重复了用户名称“YunchengLiCSDN”），但从...
南开大学软件学院2021年秋季学期研究生算法课程（复习）
Ritannn的博客
12-19 354
为什么要学习算法？ 在有限时间和内存下，编写程序正确地或有效地解决问题。 计算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
计算机专业考研复试上机算法学习
theworld666的博客
04-03 5883
计算机考研复试上机算法刷题
1.2 杰哥和数字
Clayborn voyage without an end
03-24 2346
★实验任务 杰哥特别喜欢和数字打交道，现在他有一个正整数X,他想知道有多少个满足要求的正整数D存在，要求是D是X的因子，并且D和X至少有一位相同。 ★输入格式 只有一行，一个正整数X。(N<=1000000000)。 对于30%的数据，n<=100 对于50%的数据，n<=200 对于100%的数据，n<=1000000000 ★输出格式 只有一行，一个整数表示满足要求的数...
杰哥的数字
wjx_1999的博客
09-11 1379
欢迎使用Markdown编辑器写博客 /* 杰哥特别喜欢和数字打交道，现在他有一个正整数 X,他想知道有多少个满足 要求的正整数 D 存在，要求是 D 是 X 的因子，并且 D 和 X 至少有一位相同。 */ #include &amp;amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;amp;lt;cstring&amp;amp;amp;amp;amp;g
研究生课程 算法分析-贪心法
张小彬的专栏
12-31 1106
贪心法的思想在求解一些最优化问题的时候，一般会分成多个步骤，每一步都有一个选择。贪心算法的思想在于，先不从整体考虑，每次都只做当前看来最优的思想，即局部最优解，期望通过一步步的局部最优解，最后构造出全局最优解。贪心算法是很多问题的最优解，当然也有很多问题只是局部最优，或者近似最优解，在构造贪心算法的时候，要注意贪心选择是否能求出最后的最优解。贪心算法的基本要素最优子结构性质一个问题的最优解包含其子问
UIUC研究生算法课程笔记：NP完全性、动态规划与近似算法
"这是一份来自伊利诺伊大学香槟分校教授Sariel Har-Peled的CS 573（研究生算法）课程的课堂笔记，涵盖了NP完全性、动态规划、近似算法、随机算法和线性规划等多个主题。这份笔记自2006年以来在多个学期内被用于教学...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

it00zyq

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

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

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

打赏作者

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

抵扣说明：

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

余额充值