Part1.1 基础算法-贪心算法

最新推荐文章于 2022-06-28 12:55:47 发布
最新推荐文章于 2022-06-28 12:55:47 发布
阅读量266 收藏
点赞数
分类专栏： # 信息学奥赛提高篇
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37978559/article/details/114948865
版权

Part1.1 基础算法-贪心算法

A 活动安排

法一：我们按照左端点来进行排序

将区间按照区间左端点进行从小到达排序，然后，我们来进行分析
我们贪心的来考虑，ans(答案)、ed(前一个区间的右区间)
我们用最贪心的角度来考虑，为了让1到n容纳更多的区间，我们找到两种也只有这两种可以让结果更有的方法
1.如果当前区间的右端点小于ed，那么，ed=右端点
2.如果当前区间的左端点大于ed，那么，ed=左端点，ans++；
代码如下

/*
 *@author SunLakeWalk
 */
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <limits.h>
#include <sstream>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <set>
//#pragma GCC optimize(2)
//#pragma GCC optimize(3, "Ofast", "inlin")

using namespace std;

#define ios ios::sync_with_stdio(false) , cin.tie(0)
#define x first
#define y second

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PII;

const int N = 1010, INF = 0x3f3f3f3f, mod = 1e9 + 7, base = 131;
const double eps = 1e-6, PI = acos(-1);

int n;
priority_queue<PII, vector<PII>, greater<PII>> q;

void work()
{
    ios;
    cin >> n;
    for (int i = 0; i < n; i ++ )
    {
        int x, y; cin >> x >> y;
        y --;
        q.push({x, y});
    }

    int ans = 0, st = 0, ed = 0;
    while (q.size())
    {
        PII t = q.top();
        q.pop();

        if (ed < t.x)
        {
            ans ++;
            ed = t.y;
            // cout << t.x << ' ' << t.y << endl;
        }

        if (ed > t.y)
        {
            ed = t.y;
        }
    }

    cout << ans << endl;
}

int main()
{
  //ios;
  int T = 1;
  // cin >> T;
  while (T -- )
  {
    work();
  }

  return 0;
}

法二：我们按照区间右端点进行排序 （比法一更好）

当按照区间右端点进行排序的时候，我们可以只看当前的区间左端点是否大于前面的ed，
因为，我们是按照的区间右端点进行排序的，所以，所有的区间只有两种情况，
第一种，相交，第二不相交
如果相交，还不如取前面的那一个，所以，我们可以不管，不用处理
如果不相交，那恰恰就是我们想要的，可以开展的新的一个活动

/*
 *@author SunLakeWalk
 */
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <limits.h>
#include <sstream>
#include <vector>
#include <queue>

using namespace std;

struct Node
{
    int x, y;

    bool operator> (const Node &W) const
    {
        return y > W.y;
    }
};

int n;
priority_queue<Node, vector<Node>, greater<Node>> q;

void work()
{
    cin >> n;
    for (int i = 0; i < n; i ++ )
    {
        int x, y; cin >> x >> y;
        y --;
        q.push({x, y});
    }

    int ans = 0, ed = 0;
    while (q.size())
    {
        Node t = q.top();
        q.pop();

        if (ed < t.x)
        {
          ans ++;
          ed = t.y;
        }
    }

    cout << ans << endl;
}

int main()
{
  //ios;
  int T = 1;
  // cin >> T;
  while (T -- )
  {
    work();
  }

  return 0;
}

B 种树

原本是想用区间左端点来排序，但是发现写起来好复杂呀，考虑的情况有些多。
设前一个区间是pre
要考虑：
1.pre.y >= t.y
2.pre.y>=t.y&& pre.y < t.y
3.pre.y < t.x
所以，我们还是用区间右端点来进行排序吧。
对每个区间进行一次处理
先将这个区间扫描一下，记一下已经统计的个数
然后，如果不够的话，从后往前扫描，在没种树的地方种下树。
下面是代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 100010;

struct Node
{
    int x, y, z;
};

int n, h;
Node q[N];
bool vis[N];
int ans;

bool cmp(Node a, Node b)
{
    return a.y < b.y;
}

int main()
{
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    cin >> n >> h;

    for (int i = 0; i < h; i ++ )
    {
        int x, y, z; cin >> x >> y >> z;
        q[i] = {x, y , z};
    }

    sort(q, q + h, cmp);

    Node pre = {0, 0, 0};
    for (int i = 0; i < h; i ++ )
    {
        Node t = q[i];

        int cnt = 0;
        for (int j = t.x; j <= t.y; j ++ )
        {
            if (vis[j]) cnt ++;
        }

        if (cnt < t.z)
        {
            for (int j = t.y; j >= t.x; j -- )
            {
                if (!vis[j])
                {
                    vis[j] = true;
                    cnt ++;
                    ans ++;
                }

                if (cnt == t.z) break;
            }
        }
    }

    cout << ans << endl;

    return 0;
}

C喷水装置

以区间左端点升序排序，然后，每次在有重合的区间中找到右区间延展最长的那个区间，并记录个数

下面是代码

#include <bits/stdc++.h>

using namespace std;

const int N = 20010;

struct Node
{
    double x, y;

    bool operator< (const Node &W) const
    {
      return x < W.x;
    }
}q[N];

int n, l, w;
int cnt;

void read()
{
    cin >> n >> l >> w;

    cnt = 0;
    for (int i = 0; i < n; i ++ )
    {
        double x, r; cin >> x >> r;
        if (r * 2 <= w) continue;
        double d = sqrt(r * r - w * w / 4.0);
        q[cnt].x = x - d;
        q[cnt].y = x + d;
        cnt ++;
    }
}

void solve()
{
    int ans = 0, i = 0, sign = 0;
    double ed = 0;
    while (ed < l)
    {
        ans ++;
        double s = ed;//固定前面选好的区间的右端点
        for (; q[i].x <= s && i <= cnt; i ++ )
        {
          //找到一个可以延伸最长的区间
            if (ed < q[i].y)
              ed = q[i].y;
        }

        //如果没法延伸下去，同时还没有到达尾端，则失败了
        if (ed == s && s < l)
        {
            cout << -1 << endl;
            return;
        }
    }

    cout << ans << endl;
}
int main()
{
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    int T; cin >> T;
    while (T -- )
    {
        read();
        sort(q, q + cnt);
        solve();
    }

    return 0;
}

D加工生产调度

johnson算法：
1.Mi = min(ai, bi)
2.升序排序
3.若Mi = a[i],从头开始放
若Mi = b[i]，从尾开始放

#include <bits/stdc++.h>

using namespace std;

const int N = 1010;

struct Node
{
    int x, id;

    bool operator< (const Node &W) const
    {
        return x < W.x;
    }
}m[N];

int n;
int a[N], b[N];
int ans[N], sum;

int main()
{
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    cin >> n;

    for (int i = 0; i < n; i ++ ) cin >> a[i];
    for (int i = 0; i < n; i ++ ) cin >> b[i];

    for (int i = 0; i < n; i ++ )
    {
        m[i] = {min(a[i], b[i]), i};
    }

    sort(m, m + n);

    int st = 0, ed = n - 1;
    for (int i = 0; i < n; i ++ )
    {
      // cout << m[i].id << ' ';
      if (m[i].x == a[m[i].id]) ans[st ++] = m[i].id;
      else ans[ed -- ] = m[i].id;
    }
    cout << endl;
    int t = 0;
    for (int i = 0; i < n; i ++ )
    {
        t += a[ans[i]];
        if (sum < t) sum = t;
        sum += b[ans[i]];
    }

    cout << sum << endl;
    for (int i = 0; i < n; i ++ ) cout << ans[i] + 1 << ' ';
    cout << endl;

    return 0;
}

E智力大冲浪

每个任务都有完成的最后期限，都有对应的罚款大小
贪心的来考虑。
要是罚款最少，我们要尽可能的先完成罚款较大的任务，而且要将这个任务放在期限的最左侧，以减少占用其他任务的完成。
我们将任务降序排序，然后，从当前的期限，向前遍历，如果为排满，就放上它，如果排满了，说明它过期了，要被罚，将他从从后一个位置开始照个空位放上去。
算法证明：
如果次算法不是最优的，说明有一个过期的任务k，可以安排进日期内。
如果，我们要将他放进合法日期内，就必须将其中一个任务拿出来，但是，因为我们是按照任务的罚款降序排序，所以合法日期
内的所有数字都不小于当前日期的罚款，那我们这么操作，不会产生更优的结果，所以，算法得证。

#include <bits/stdc++.h>

using namespace std;

const int N = 1010;

int n, m;
struct Node
{
    int t, w;

    bool operator< (const Node &W) const
    {
        return w > W.w;
    }
}q[N];

bool vis[N];
int ans = 0;

int main()
{
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    cin >> m >> n;
    for (int i = 1; i <= n; i ++ ) cin >> q[i].t;
    for (int i = 1; i <= n; i ++ ) cin >> q[i].w;

    sort(q + 1, q + 1 + n);

    // for (int i = 1; i <= n; i ++ ) cout << q[i].w << ' ';
    // cout << endl;
    for (int i = 1; i <= n; i ++ )
    {
        bool has_find = false;
        for (int j = q[i].t; j >= 1; j -- )
        {
            if (!vis[j])
            {
              has_find = true;
              vis[j] = true;
              break;
            }
        }

        if (!has_find)
        {
            int j;
            for (j = n; j >= 1; j -- )
            {
                if (!vis[j])
                {
                  vis[j] = true;
                  break;
                }
            }

            ans += q[i].w;
        }
    }

    cout << m - ans << endl;

    return 0;
}

E智力大冲浪

很常规的贪心问题。

#include <bits/stdc++.h>

using namespace std;

const int N = 1010;

int n, m;
struct Node
{
    int t, w;

    bool operator< (const Node &W) const
    {
        return w > W.w;
    }
}q[N];

bool vis[N];
int ans = 0;

int main()
{
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    cin >> m >> n;
    for (int i = 1; i <= n; i ++ ) cin >> q[i].t;
    for (int i = 1; i <= n; i ++ ) cin >> q[i].w;

    sort(q + 1, q + 1 + n);

    // for (int i = 1; i <= n; i ++ ) cout << q[i].w << ' ';
    // cout << endl;
    for (int i = 1; i <= n; i ++ )
    {
        bool has_find = false;
        for (int j = q[i].t; j >= 1; j -- )
        {
            if (!vis[j])
            {
              has_find = true;
              vis[j] = true;
              break;
            }
        }

        if (!has_find)
        {
            int j;
            for (j = n; j >= 1; j -- )
            {
                if (!vis[j])
                {
                  vis[j] = true;
                  break;
                }
            }

            ans += q[i].w;
        }
    }

    cout << m - ans << endl;

    return 0;
}

F 数列极差

很常规的贪心

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <limits.h>
#include <sstream>
#include <cctype>
#include <numeric>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <set>
//#pragma GCC optimize(2)
//#pragma GCC optimize(3, "Ofast", "inlin")

using namespace std;

#define ios ios::sync_with_stdio(false) , cin.tie(0)
#define x first
#define y second

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PII;

const int N = 100010, INF = 0x3f3f3f3f, mod = 1e9 + 7, base = 131;
const double eps = 1e-6, PI = acos(-1);

int n;
priority_queue<int> q1;
priority_queue<int, vector<int>, greater<int> > q2;

void work()
{
    int x;
    cin >> n;
    while (n -- )
    {
      cin >> x;
      q1.push(x);
      q2.push(x);
    }

    int t = q1.top();
    q1.pop();
    while (q1.size())
    {
      t = t * q1.top() + 1;
      q1.pop();
    }
    // cout << t << "\n";

    // cout << q1.top() << "\n";
    while (q2.size() > 1)
    {
      x = q2.top();
      q2.pop();
      int y = q2.top();
      q2.pop();
      q2.push(x * y + 1);
    }

    // cout << q2.top() << "\n";
    // cout << q2.size() << "\n";
    cout << q2.top() - t << "\n";
}

int main()
{
  //ios;
  int T = 1;
  // cin >> T;
  while (T -- )
  {
    work();
  }

  return 0;
}

G 数列分段

很常规的贪心

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <limits.h>
#include <sstream>
#include <cctype>
#include <numeric>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <set>
//#pragma GCC optimize(2)
//#pragma GCC optimize(3, "Ofast", "inlin")

using namespace std;

#define ios ios::sync_with_stdio(false) , cin.tie(0)
#define x first
#define y second

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PII;

const int N = 100010, INF = 0x3f3f3f3f, mod = 1e9 + 7, base = 131;
const double eps = 1e-6, PI = acos(-1);

int cnt, sum;
int n, m;
int a[N];

void work()
{
    scanf("%d%d", &n, &m);

    cnt = 1;
    for (int i = 0; i < n; i ++ )
    {
      int x; scanf("%d", &x);
      if (sum + x > m)
      {
        cnt ++;
        sum = x;
      }
      else
      {
        sum += x;
      }
    }
    printf("%d\n", cnt);
}

int main()
{
  //ios;
  int T = 1;
  // cin >> T;
  while (T -- )
  {
    work();
  }

  return 0;
}

H 线段

很常规的贪心思想

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <limits.h>
#include <sstream>
#include <cctype>
#include <numeric>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <set>
//#pragma GCC optimize(2)
//#pragma GCC optimize(3, "Ofast", "inlin")

using namespace std;

#define ios ios::sync_with_stdio(false) , cin.tie(0)
#define x first
#define y second

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PII;

const int N = 1000010, INF = 0x3f3f3f3f, mod = 1e9 + 7, base = 131;
const double eps = 1e-6, PI = acos(-1);

int n;
struct Node
{
  int x, y;
  bool operator< (const Node &W) const
  {
    return y < W.y;
  }
}a[N];

void work()
{
  scanf("%d", &n);
  for (int i = 1; i <= n; i ++ )
  {
    int x, y; scanf("%d%d", &x, &y);
    a[i] = {x, y};
  }

  sort(a + 1, a + 1 + n);

  int cnt = 0;
  int ed = -1;
  for (int i = 1; i <= n; i ++ )
  {
    int x = a[i].x, y = a[i].y;
    // printf("%d %d %d\n", ed, x, y);
    if (ed <= x)
    {
      cnt ++;
      ed = y;
    }
    else
    {
      continue;
    }
  }

  printf("%d\n", cnt);
}

int main()
{
  //ios;
  int T = 1;
  // cin >> T;
  while (T -- )
  {
    work();
  }

  return 0;
}

F家庭作业

按照绩点从高到底排序，然后顺序选择结束时间，每次判断是否当前时间是否被用过，如果没有，就选当前的成绩，如果被用了，就去找当前时间前面的最高成绩
首先贪心的来考虑，按照绩点从高到低来排序，然后，我们尽量将当前的作业放到结束之前尽可能靠后的位置**{在结束之前找一个空闲的位置，如果自己的位置空着，就放在当前，否则就放在靠自己最近的位置}**。因为，如果放到结束时间后就不会产生贡献，放在靠前的位置一定不如靠后的位置更优。假设当前完成时间为t，靠前位置为t-a，靠后位置为t-b，且a<b，对于完成时间t，能放在t-a，同时一定能放在位置t-b，同时，放在t-b的位置一定能比放在t-a占的完成时间在（t-a）前面的位置更少。所以，放的越靠后越贪心。

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1000010;

struct Node
{
  int t, c;

  bool operator< (const Node &W) const
  {
    if (c == W.c) return t < W.t;
    return c > W.c;
  }
}a[N];

int n;
int pre[N];//指向当天的前一天
bool st[N];

int get(int x)
{
  if (!st[x])
  {
    //如果当前这一天没有被占用的话，
    //那就很好直接用当前这一天一定是最贪心的。
    // st[x] = true;
    return x;
  }
  else
  {
    //否则的话，就向前去找， 如果没有被用掉就可以使用这一天
    //这一定是最贪心的
    //假设最贪心的不是这一天t，而是这一天前面的某一天tt的话
    //后面的任务能放到tt前面的，一定被t前面的天包括。
    // int t = get(pre[x]);
    // pre[x] = t;
    // return t;
    return pre[x] = get(pre[x]);
  }
}
int main()
{
  scanf("%d", &n);
  for (int i = 1; i <= 700000; i ++ )
    pre[i] = i - 1;

  for (int i = 1; i <= n; i ++ )
  {
    scanf("%d%d", &a[i].t, &a[i].c);
  }

  sort(a + 1, a + 1 + n);

  int sum = 0;
  for (int i = 1; i <= n; i ++ )
  {
    int t = a[i].t;
    int k = get(t);
    if (!k) continue;
    st[k] = true;
    // printf("%d\n", k);
    if (k) sum += a[i].c;
  }

  printf("%d\n", sum);

  return 0;
}

J钓鱼

直接暴力啊。。。。

/*
题目说从第一个鱼塘往右走，在当前鱼塘停留若干时间后接着往下一个鱼塘走
直到时间被消耗完。
因为不好知道到底在那个地方停下，直觉上感觉这个题可以二分
二分最后停留的鱼塘的位置，100个鱼塘，最多二分七次就OK了
先给消耗的时间加上经过鱼塘消耗的时间

好吧，不能二分。。。
不具备单调性哦

然后，维护一个大根堆。
每次取出当前可钓的鱼的最大数量，然后将减少后的鱼量放进去
如果在时间还没有消耗完的情况下，出现了负数的情况就直接退出循环
 */
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>

using namespace std;

typedef pair<int, int> PII;

#define x first
#define y second

const int N = 110;

int n, m;
int a[N], t[N], s[N];
int ans;

int work(int pos)
{
  int ans = 0;
  int sum = s[pos];//消耗pos个五分钟
  if (sum >= m) return -1;
  priority_queue<PII> q;
  for (int i = 1; i <= pos; i ++ )
    q.push({a[i], t[i]});
  // printf("%d\n", pos);
  // printf("%10d     %d\n", sum, m);
  while (sum < m)//消耗时间要小于总时间
  {
    PII t = q.top();
    q.pop();
    // printf("%d %d\n", t.x, t.y);
    if (t.x < 0)
    {
      break;
    }

    ans += t.x;
    q.push({t.x - t.y, t.y});
    sum ++;
  }
  // printf("%d\n", ans);
  return ans;
}

// bool check(int mid)
// {
//   int cnt = work(mid);
//   // printf("%d\n", mid);
//   puts("--------------------------");
//   // printf("%10d     %d\n", mid, cnt);
//   if (cnt > ans)
//   {
//     ans = cnt;
//     return true;
//   }
//   return false;
// }
int main()
{
    scanf("%d%d", &n, &m);
    m *= 12;
    for (int i = 1; i <= n; i ++ ) scanf("%d", &a[i]);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &t[i]);
    for (int i = 2; i <= n; i ++ )
    {
      int x; scanf("%d", &x);
      s[i] = s[i - 1] + x;
    }

    // int l = 1, r = n;
    // while (l <= r)
    // {
    //   int mid = l + r >> 1;
    //   if (check(mid)) r = mid;
    //   else l = mid + 1;
    //   printf("%d %d %d\n", l, mid, r);
    // }

    for (int i = 1; i <= n; i ++ )
      ans = max(ans, work(i));
    printf("%d\n", ans);

    return 0;
}

K糖果传递

设x为前一个小朋有需要向后一个小朋友传递的糖果数，下面我们将题目进行转化
在这里插入图片描述
【我也搞不清要不要裂开，似乎是需要裂开的，这样才能像仓库选址，因为仓库选址本身就是在一条直线上的】在众多x中，因为他们自己的糖果数不同，所以他们相互传递的糖果数也不同，所以会出现x是正数、负数、和0.我们找到一个位置，这里的a的右边是负数，左边是正数或0。可以将这个点拆开，变成一条链。这个点表示，需要向左边分配0个或多个糖果，也也要向右边分配糖果。
再结合前面我们转化的关系， 这样我们会发现，我们要让|xn - S1|, |xn - S2|, |xn - s3|, ...., |xn - Sn|最小，这就是需要先排个序，然后在中间位置坐标的点选择建立仓库，然后计算最短距离之和。就变成了仓库选址模型了。

太阳湖散步
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
VulkanSDK-1.1.92.1-Installer.exe part2（2-2）
05-08
安装包分两个部分VulkanSDK-1.1.92.1-Installer.exe part2 VulkanSDK-1.1.92.1-Installer.exe part2
算法导论之贪心算法：带惩罚的任务调度算法
WSYW126的博客
06-04 7905
带惩罚的任务调度问题
贪婪算法（greedy Algorithm)
qq_43720551的博客
03-27 3118
当我们解决问题时，为了找到全局最优解，我们通过在每个步骤寻找局部最优解 缺点：很少时候我们能够获得全局最优 举例： 如果我们要从第一个结点开始寻找最大的路径: greedy： 1+3+7=11 真正的 1+2+4+8+12=27 因此，局部最优解不一定会得到全局最优解 我们什么时候可以使用 满足两个条件： 1.全局最优可以由局部最优得到 2.最优子结构： an optimal solution ...
写出ELGamal公钥密码算法的加密、解密过程
热门推荐
qq_14858923的博客
04-23 1万+
1、写出ELGamal公钥密码算法的加密、解密过程 2、假设p=2579,a＝2，d＝765,试用ElGamal公钥算法对明文m=1299进行加密（选取的随机整数k=853），并用解密算法验证其结果的正确性。程序： #include<iostream> using namespace std; int modmi(int x,int r,int n){ int a=x,b=r,c=1;
【板子】gcd、exgcd、乘法逆元、快速幂、快速乘、筛素数、快速求逆元、组合数...
dingguayi7025的博客
07-29 184
1.gcd int gcd(int a,int b){ return b?gcd(b,a%b):a; } 2.扩展gcd )extend great common divisor ll exgcd(ll l,ll r,ll &x,ll &y) { if(r==0){x=1;y=0;return l;} els...
欧拉函数的实现（C语言）
Binary_huang的简介
06-28 2426
求一个数的互质数的个数
创新算法ARIZ-85C
06-13
### 创新算法ARIZ-85C：深入解析与应用 #### 一、概览 **ARIZ-85C**(Algorithm of Inventive Problem Solving)是TRIZ理论体系中的核心工具之一，由苏联发明家及TRIZ创始人根里奇·阿奇舒勒（G.S. Altshuller）在...
算法参考资料Dynamic-Programming-Theory-Part-2
04-15
算法参考资料Dynamic_Programming_Theory_Part_2提取方式是百度网盘分享地址
算法参考资料Dynamic-Programming-Theory-Part-1
04-15
算法参考资料Dynamic_Programming_Theory_Part_1提取方式是百度网盘分享地址
第16章-序列号生成算法分析-Part11
08-03
第 16 章-序列号生成算法分析-Part1本章,我们分析的 CrackMe 与之前的不同之处在于序列号是基于名称变化的,也就是说我们将讨论序列号生成算法。尽管
快速幂与快速幂取模
a921893396的博客
01-18 272
快速幂与快速幂求模 普通的暴力求法 int mi(int a,int b) { int num=1; int i; for(i=0;i<b;i++) { num=num*a; } return num; } 这种暴力求法的时间复杂度是O(n)，为了降低时间复杂度，我们引用快速幂，它的时间复杂度缩短到O(logn)。 快速幂的核心 我认为快速幂之所以快，主要是运用到了位运算。...
贪心算法入门
鸭梨的博客
05-22 141
和大多数计算机科学的术语一样，贪心算法（greedy algorithm）策略被命名得非常地契合。被归类为贪心算法的常见模式是： 在做出选择的时候，算法总是选择目前看起来最好的选择。 贪婪策略通常被用来解决最优化问题。最优化问题通常包含这些短语之一：什么是最好的、什么是最小的或者什么是最大的。 最优化问题的一个例子是： 如果总共有42美分，那么最少有多少个硬币？在美国，你可以选择的硬币有25美分、10美分、5美分、2美分这几个。 这是一个可以用贪婪策略来解决的问题。贪婪策略总会选择能够选的最大的硬币。
【算法图解】 之 [贪婪算法（贪心算法）] 详解
May女子の博客
07-23 3928
入门算法学习，看的第一本是深入浅出的《算法图解》一书，本博客是对《算法图解》一书的学习笔记，将书中的分享的算法示例用Python3语言实现。 如果你也想要阅读这本书，百度云盘链接：https://pan.baidu.com/s/1s967vfgEBd1vSrfwVI9Y3g 提取码：【be9k】 或者也可以留言你的邮箱，我将PDF共享给你~ 贪婪算法 贪婪算法（又称贪心算法）是指，在对问题求...
信息技术教师技能大赛基础知识与专业技能试卷.doc
08-16
信息技术教师技能大赛基础知识与专业技能试卷.doc
基于ssm的新生报到系统(有报告) Javaee项目，ssm项目
最新发布
08-16
资源详情：https://blog.csdn.net/2302_78191516/article/details/141269772
奥柯玛DC16A电磁炉原理图.rar
08-16
奥柯玛DC16A电磁炉原理图
麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包
08-16
麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包
java-学生比赛指导管理系统（源码+数据库+论文）.rar
08-16
针对当前高校各类竞赛的报名现状，本文利用JSP技术以及Mysql数据库开发设计一款针对高校比赛指导及报名的线上平台，学生用户可以通过线上平台及时了解到高校内的各类赛事信息及规则，通过页面信息的了解可以实现在线的报名，对于报名审核通过的学生用户可以获得对应的比赛指导资料，利用线上平台帮助更好的提升比赛信息的传播范围以及比赛报名的效率，通过流程化和线上化的平台帮助建立在线的比赛报名及信息传递的平台。 关键词：JSP技术；Mysql数据库；比赛管理；在线报名；
用ESP8266-01S远程物联控制电器的程序
08-16
用ESP8266-01S远程物联控制电器的程序
贪心与动态规划算法详解
"《Algorithms Illuminated Part 3_ Greedy Algorithms and Dynamic Programming》是Tim Roughgarden撰写的一本书，旨在帮助读者深入理解贪心算法和动态规划这两种在计算机科学和IT领域至关重要的算法。这本书强调了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值