m0_48711099的博客

小迷妹在哪儿 选择相同迷妹的情况下，交换任意两个小迷妹的顺序可以列不等式证明性价比高的先找更优 #include <algorithm> #include <iostream> #include <vector> using namespace std; struct fan{ int score; int time; }; bool cmp(fan a,fan b){ //按性价比排序 return a.score*b.

#include <iostream> #include <algorithm> #include <vector> #include <math.h> using namespace std; //动态规划 构建一个二维数组 dp[i][target] 表示从0到达i的时候 能否构建成和为target的真假值 void judge(int sum,vector<int>& weight,vector<int>&tar

POJ 3278 抓住那头牛 #include <iostream> #include <algorithm> #include <queue> using namespace std; const int MAXN=1e5+10; bool visit[MAXN]; struct Status{ int position; int time; Status(int p,int t):position(p),time(t){} }; int B

#include <iostream> #include <algorithm> using namespace std; const int MAXN=10; bool visit[MAXN]; char sequence[MAXN]; void GetPermutation(string s,int index){ if(index==s.size()){ for(int i=0;i<s.size();++i){ print

POJ 1328 雷达安装 #include <iostream> #include <algorithm> #include <cmath> using namespace std; const int MAXN=1000+10; struct Interval { double left; double right; }; Interval arr[MAXN]; bool cmp(Interval a,Interval b){ r

#include <iostream> #include <algorithm> using namespace std; const int MAXN=100; struct program { int startTime; int endTime; }; bool cmp(program a,program b){ return a.endTime<b.endTime; } program arr[MAXN]; int main() {

#include <iostream> #include <algorithm> #include <vector> #include <string.h> #include <queue> #include <climits> using namespace std; const int MAXN=200; //顶点数 const int INF=INT_MAX; struct Edge{ //边的结构

#include <iostream> #include <algorithm> using namespace std; const int MAXN=100; //顶点数 int father[MAXN]; int height[MAXN]; struct Edge{ //边的结构体 int from; int to; int length; bool operator < (const Edge &e

拿了第i号物品后依然可以再拿第i号物品，考虑第i个物品的状态转移方程改一点 #include <iostream> using namespace std; const int MAXN=100+10; const int MAXM=1e5+10; int dp[MAXN][MAXM]; int weight[MAXN]; int value[MAXN]; int main() { int n,m; while (scanf("%d",&n)!=EOF){ .

最优子结构性质：大问题的最优解可以由小问题的最优解推出 无后效性：一旦f(n)确定，如何凑出f(n)就再也用不着了 如何判断一个问题能否使用DP解决： 能将大问题拆成小问题，且满足无后效性、最优子结构性质 DP为什么这么快： 暴力解法是枚举所有的可能解，这是最大的可能解空间 DP枚举有希望成为答案的解，这个空间比暴力小得多，即DP自带剪枝 其核心思想就是尽量缩小解空间 DP操作过程：（有记忆的递归） 将一个大问题转化成几个小问题 求解小问题 推出大问题的解 dp[i][j]表示考虑前i个物品在容重为j的情况

#include <iostream> using namespace std; const int MAXN=1000+10; string s1,s2; int fun1(int n,int m){ //直接递归，时间复杂度O(2^(n+m)) int answer; if(n==0||m==0) answer=0; else{ if(s1[n]=s2[m]) answer=fun1(n-1,m-1)+1; else ans..

/** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ struct ListNode* reverseList(struct ListNode* head){ if(head == NULL || head->next == NULL) return head; struct ListNode* pre=

#include<iostream> using namespace std; int f(int n, int m){ return n == 1 ? n : (f(n - 1, m) + m - 1) % n + 1; } int main(){ int n,m; cin>>n>>m; cout<<f(n,m); system("pause"); return 0; }

#include <iostream> #include <algorithm> #include <vector> #include <map> using namespace std; vector<int> post, in; map<int, int> level; void pre(int root,int start,int end,int index){ //root子树根结点在后序中位置,start和end分别为子

#include <iostream> #include <algorithm> #include <vector> using namespace std; struct node { int id, l, r, index, level; } a[100]; vector<node> v1; bool cmp(node a,node b){ if(a.level!=b.level) return a.level<b.level;

1067 Sort with Swap(0, i) #include <iostream> #include <vector> using namespace std; int main(){ int n,cnt=0; cin>>n; vector<int> a(n); for(int i=0;i<n;i++){ scanf("%d",&a[i]); } for(int i = 1

#include <iostream> #include <algorithm> #include <vector> using namespace std; int main(){ int Nc,Np,temp,res=0; scanf("%d",&Nc); vector<int> coupons(Nc); for(int i=0;i<Nc;i++){ scanf("%d",&coupo

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 解释：342 + 465 = 807. LeetCode原题链接 class Solution { public: ListNode* addTwoNumbers(ListNode*

最大子序和 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 示例 1： 输入：nums = [-2,1,-3,4,-1,2,1,-5,4] 输出：6 解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。 示例 2： 输入：nums = [1] 输出：1 示例 3： 输入：nums = [0] 输出：0 示例 4： 输入：nums = [-1] 输出：-1 示例 5： #include<iostream> #include<ve

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。 你可以按任意顺序返回答案。 示例 1： 输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。 示例 2： 输入：nums = [3,2,4], target = 6

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的数字可以无限制重复被选取。 说明： 所有数字（包括 target）都是正整数。 解集不能包含重复的组合。 #include<iostream> #include<vector> #include <algorithm> using namespace std; class Solution {

#include<iostream> using namespace std; int* queen = new int[8]; int count=0; bool IsLegal(int currentrow, int currentcolum) { for (int precolum = 0; precolum < currentrow; precolum++) { int row = queen[precolum]; if (row