Crested Ibis vs Monster——AT动态规划思想

简介: 题目描述Ibis is fighting with a monster.The health of the monster is H.Ibis can cast N kinds of spells. Casting the i-th spell decreases the monster’s health by Ai, at the cost of Bi Magic Points.The same spell can be cast multiple times.

题目描述


Ibis is fighting with a monster.

The health of the monster is H.

Ibis can cast N kinds of spells. Casting the i-th spell decreases the monster’s health by Ai, at the cost of Bi Magic Points.

The same spell can be cast multiple times. There is no way other than spells to decrease the monster’s health.

Ibis wins when the health of the monster becomes 0 or below.

Find the minimum total Magic Points that have to be consumed before winning.


Constraints

·1≤H≤104

·1≤N≤103

·1≤Ai≤104

·1≤Bi≤104

·All values in input are integers.


输入


Input is given from Standard Input in the following format:


H N
A1 B1
:
AN BN


输出


Print the minimum total Magic Points that have to be consumed before winning.


样例输入


【样例1】
9 3
8 3
4 2
2 1
【样例2】
100 6
1 1
2 3
3 9
4 27
5 81
6 243
【样例3】
9999 10
540 7550
691 9680
700 9790
510 7150
415 5818
551 7712
587 8227
619 8671
588 8228
176 2461


样例输出


【样例1】
4
【样例2】
100
【样例3】
139815


提示


样例1解释

First, let us cast the first spell to decrease the monster’s health by 8, at the cost of 3 Magic Points. The monster’s health is now 1.

Then, cast the third spell to decrease the monster’s health by 2, at the cost of 1 Magic Point. The monster’s health is now −1.

In this way, we can win at the total cost of 4 Magic Points.

样例2解释

It is optimal to cast the first spell 100 times.


#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector,fast-math")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize (2)
#pragma G++ optimize (2)
#include <bits/stdc++.h>
#include <algorithm>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define wuyt main
typedef long long ll;
#define HEAP(...) priority_queue<__VA_ARGS__ >
#define heap(...) priority_queue<__VA_ARGS__,vector<__VA_ARGS__ >,greater<__VA_ARGS__ > >
template<class T> inline T min(T &x,const T &y){return x>y?y:x;}
template<class T> inline T max(T &x,const T &y){return x<y?y:x;}
///#define getchar()(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++)
///char buf[(1 << 21) + 1], *p1 = buf, *p2 = buf;
ll read(){ll c = getchar(),Nig = 1,x = 0;while(!isdigit(c) && c!='-')c = getchar();
if(c == '-')Nig = -1,c = getchar();
while(isdigit(c))x = ((x<<1) + (x<<3)) + (c^'0'),c = getchar();
return Nig*x;}
#define read read()
const ll inf = 1e15;
const int maxn = 2e5 + 7;
const int mod = 1e9 + 7;
#define start int wuyt()
int num[maxn];
ll ans;
int main() {
    int h=read,n=read;
    vector<int> dp(h+1, mod);
    dp[0]=0;
    for(int i=0;i<n;i++)
    {
        int a=read,b=read;
        for(int j=0;j<h;j++)
        {
            int temp=min(j+a,h);
            dp[temp] = min(dp[temp],dp[j]+b);
        }
    }
    printf("%d\n",dp[h]);
    return 0;
}
目录
相关文章
|
1月前
|
算法 Python
在Python编程中,分治法、贪心算法和动态规划是三种重要的算法。分治法通过将大问题分解为小问题,递归解决后合并结果
在Python编程中,分治法、贪心算法和动态规划是三种重要的算法。分治法通过将大问题分解为小问题,递归解决后合并结果;贪心算法在每一步选择局部最优解,追求全局最优;动态规划通过保存子问题的解,避免重复计算,确保全局最优。这三种算法各具特色,适用于不同类型的问题,合理选择能显著提升编程效率。
55 2
|
2月前
|
算法 C++
【算法解题思想】动态规划+深度优先搜索(C/C++)
【算法解题思想】动态规划+深度优先搜索(C/C++)
|
7月前
动态规划基础
动态规划基础
64 0
|
7月前
|
算法
回溯算法思想
回溯算法思想
45 0
|
7月前
|
存储 缓存 算法
【算法训练-动态规划 零】动态规划解题框架
【算法训练-动态规划 零】动态规划解题框架
106 0
|
存储 人工智能 分布式计算
动态规划从理论到实践-深入理解贪心/分治/回溯/动态规划的算法思想
动态规划从理论到实践-深入理解贪心/分治/回溯/动态规划的算法思想
255 0
|
存储 人工智能 算法
【算法分析与设计】动态规划(上)
【算法分析与设计】动态规划(上)
|
人工智能 算法
贪心算法思想与练习
贪心算法思想与练习
133 2
|
算法
算法设计初步之动态规划
算法设计初步之动态规划