第二十五周代码（蓝桥杯查缺补漏）

news2024/10/7 20:26:40

2024/03/31        周日

填充

题目链接

【参考代码】

想用暴力，没过

//枚举，未出结果QAQ

#include <bits/stdc++.h>

using namespace std;

string s00 = "00";

string s11 = "11";

int ans = 0;

//m个问号，子串有2^m种，使用dfs

//初步思路：分割子串，直到只有两位

int calculate(string s)

{

    int substringCount = 0;

    if(s.size() == 2)

    {   

        if(s == s00 || s == s11)

            substringCount++;

        return substringCount;

    }

    int mid = s.size() >> 1;

    calculate( s.substr(0, mid) );

    calculate( s.substr(mid+1, mid+1) );

}

void dfs(string s)

{

    if(s.find('?') == -1)

    {

        ans = max(calculate(s), ans)

        return;

    } 

    int index = s.find('?');

    for(int i=0;i<=1;i++)

    {

        s[index] = i;

        dfs(s);

    }

}

int main()

{

    string input;

    cin>>input;

    dfs(input);

    return 0;

}

Accepted贪心，贪心比枚举还要短

#include <bits/stdc++.h>
using namespace std;

int main() //贪心
{
    int substringCount = 0;
    string s;
    cin>>s;
    for(int i=0;i<s.size()-1;i++)//防止越界，以倒数第二位作为结束条件
    {
        if(s[i] == s[i+1] || s[i] == '?' || s[i+1] == '?')
        {
            substringCount++;
            i++; //避免重复计算
        }    
    }
    cout << substringCount << endl;
}

动态规划

#include <bits/stdc++.h>
using namespace std;

const int N = 1e6+1;
int dp[N];

int main() //动态规划
{
    string s;
    cin>>s;
    //三种状态转移方程：
    if(s[0] == s[1] || s[0] == '?' || s[1] == '?') //初始化
        dp[1] = 1; //dp[0]=0
    for(int i=2;i<s.size();i++)
    {
        dp[i] = dp[i-1]; //当前字符可以和前一个字符拼接，但是不拼接
        if(s[i] == s[i-1] || s[i] == '?' || s[i-1] == '?')
            //dp[i-2]+1可以和前一个字符拼接，选择拼接
            //不拼接和拼接选一个最大值为最优解
            dp[i] = max(dp[i-1], dp[i-2]+1); //max(1,1)
    }
    cout << dp[s.size()-1] << endl;
}

奇怪的数

题目链接

【参考代码】

模拟10%通过

#include <bits/stdc++.h>
using namespace std;

const int mod = 998244353;

int main()
{
    //模拟10%
    int n, m;
    long long ans = 1;
    cin>>n>>m; //长度为n、连续数位和不大于m
    if(n == 0 || m == 0 || m < ceil(n/2))
    {
        cout << 0 << endl;
        return 0;
    }
    int forCount = 0;
    for(int i=2; i <= m - ceil(n/2); i += 2) //天花板，向上取整
    {
        ans += n; //n位数101010101.....一位加2，其他不变，n种情况
        forCount++;
        if(forCount == 4)
        {
            forCount = 0;
            n = n-1;
        }
        if(n == 0)
            break;
    }
    cout << ans % mod << endl;
    return 0;
}

看到4维的dp数组，累了，放个别人的题解

#include <iostream>
using namespace std;

int dp[10][10][10][10]; //看到这玩意就不想看了
int N = 998244353;

int main() {
    int n, m;
    cin >> n >> m;
    int res = 0;
    //初始化边界
    for (int i = 1;i <= 9;i += 2) {
        for (int j = 0;j <= 9 && j <= (m - i);j += 2) {
            for (int k = 1;k <= 9 && k <= (m - i - j);k += 2) {
                for (int t = 0;t <= 9 && t <= (m - i - j - k);t += 2) {
                    dp[i][j][k][t] = 1;
                }
            }
        }
    }
    //dp[i][j][k][t] -> p j k t q -> dp[j][k][t][q](将之前的结果存在这里)
    //开始动态规划
    //q是对应当前的位置的，比如n = 5的时候，q就是第五位，就应该是奇数位可以用i % 2直接得到起始条件，
    //再基于q得到上面的t k j p即可
    for (int i = 5;i <= n;i++) {
        for (int p = i % 2;p <= 9;p += 2) {
            for (int j = (i + 1) % 2;j <= 9 && (j <= m - p);j += 2) {
                for (int k = i % 2;k <= 9 && (k <= m - p -j); k += 2) {
                    for (int t = (i + 1) % 2;t <= 9 && t <= (m - p - j -k);t += 2) {
                        for (int q = i % 2;q <= 9 && q <= (m - p - j - k - t);q += 2) {
                            //dp[j][k][t][q]是没有被初始化的 我们最开始初始化的是奇偶奇偶 现在是偶奇偶奇
                            dp[j][k][t][q] += dp[p][j][k][t];
                            dp[j][k][t][q] %= 998244353;
                        }
                        //因此这里还需要归零
                        dp[p][j][k][t] = 0;
                    }
                }
            }
        }
    }
    //因此直接把最后四位累加起来即可
    for (int j = (n + 1) % 2;j <= 9 && (j <= m);j += 2) {
        for (int k = n % 2;k <= 9 && (k <= m - j); k += 2) {
            for (int t = (n + 1) % 2;t <= 9 && t <= (m - j -k);t += 2) {
                for (int q = n % 2;q <= 9 && q <= (m - j - k - t);q += 2) {
                    //dp[j][k][t][q]是没有被初始化的 我们最开始初始化的是奇偶奇偶 现在是偶奇偶奇
                    res += dp[j][k][t][q];
                    res %= 998244353;
                }
            }
        }
    }
    cout << res << endl;
    return 0;
}

刷点简单的：

三带一

题目链接

【参考代码】

打牌，炸弹不算三带一

题解区还有更简单的做法

#include <bits/stdc++.h>
using namespace std;

map<char, int> mp;

int main() //dp写不下去了，写点简单题
{
  // map含有clear函数，大大方便了清零效率，也不用另外写一段
  int t;
  string s;
  cin>>t;
  while(t--)
  {
      mp.clear();
      cin>>s;
      for(int i=0;i<4;i++)
      {
          mp[s[i]]++;
      }
      int temp = 0;
      for(int i=0;i<4;i++)
          temp = max(mp[s[i]], temp);     
      if(temp == 3)
          cout << "Yes" << endl;
      else
          cout << "No" << endl;
  }
  return 0;
}

数树数

题目链接

【参考代码】

数学思维题，左孩子结点数是根结点数*2-1。右孩子结点数是根结点数*2

#include <iostream>
using namespace std;
int main()
{
    int n, q;
    string s;
    cin>>n>>q;
    for(int i=0;i<q;i++)
    {
        int number = 1; //记得重置
        cin>>s;
        for(int j=0;j<s.size();j++)
        {
            if(s[j] == 'L')
                number = number * 2 - 1;
            else
                number = number * 2;
        }
        cout << number << endl;
    }
    return 0;
}

奇怪的捐赠

题目链接

【参考代码】

#include <iostream>
using namespace std;

int f(int x, int money)
{
  while(x < money)
  {
      x *= 7;
  }
  return x/7;
}

int main() //计算器加程序，1份还是3份是用计算器算的
{
  int money = 1e6; //100w
  int count = 0, x1=1;
/*
  money = money - 1*f(1, money);
  money = money - 1*f(1, money);
  money = money - 3*f(1, money);
  money = money - 3*f(1, money);
  money = money - 3*f(1, money);
  money = money - 3*f(1, money);
  money = money - 1*f(1, money);
  money = money - 1*f(1, money);
*/
  cout << 16 << endl;
  return 0;
}

三角回文数

题目链接

【参考代码】

#include <bits/stdc++.h>
using namespace std;
/*
出现的问题：
1.没有输出结果，范围设置太小（20230514），导致没有搜素到合适
2.输出结果未大于20220514，三角回文数不是末项，而是等差数列的总和求出后，再作回文判断
*/
int main()
{
    cout << 35133153 << endl;
    int sum = 0;
    for(int k=1; ; k++)
    {
        sum += k; //等差数列 = 三角数，不需要再判断
        if(sum > 20220514)
        {
            string s = to_string(sum);
            string tmp = s;
            reverse(tmp.begin(), tmp.end());          
            if(s == tmp)
            {
                cout << sum << endl;
                return 0;
            }
        }
    }
    
}

2024/04/02        周二

子树的大小

题目链接

【参考代码】

#include <iostream>
using namespace std;
typedef long long ll;

int main()
{
  int t;
  cin>>t;
  while(t--)
  {
      int n, m, k; //n个结点，m茶树，第k点
      cin>>n>>m>>k;
      ll ans = 1;
      ll leftchild = (k - 1) * m + 2;
      ll rightchild = k * m + 1;
      while(rightchild <= n)
      {
          ans += rightchild - leftchild + 1; //加回本身的点
          leftchild = (leftchild - 1) * m + 2; //leftchild继续增加
          rightchild = rightchild * m + 1; //rightchild继续增加
      }
      if(leftchild <= n)
      {
          ans += n - leftchild + 1;
      }
      cout << ans << endl;
  }
  return 0;
}

阶乘的和

题目链接

【参考代码】

#include <bits/stdc++.h>
using namespace std;
typedef long long ll; 
//      阶乘          1  2  3   4   5    6    7      8      9
int factorial[] = {0, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};
// 规律：3个2就是6, 4个6（3！）就是24（4！），5个24（4！）就是120（5！）
const int N = 1e5+1;
map<ll, int> factor; //因数

int main()
{
    int n;
    ll temporary;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>temporary;
        factor[temporary]++;
    }
    for(auto it=factor.begin(); it!=factor.end(); it++)
    {
        temporary = it->first;
        int numbercount = it->second;
        if(numbercount % (temporary+1) == 0)
        {
            factor[temporary+1] += numbercount / (temporary+1);
        }
        else
        {
            cout << temporary << endl; 
            return 0;
        }
    }
}

2024/04/03        周三

蓝桥公园（Floyd算法）

题目链接

【参考代码】

#include <bits/stdc++.h>
using namespace std;

const long long INF = 0x3f3f3f3f3f3f3f3f;
const int N = 401;
long long f[N][N];
int n, m, q;

void floyd()
{
    for(int k=1; k<=n; k++)
    {
        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=n; j++)
            {
                f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
            }
        }
    }
}

int main()
{
    memset(f, 0x3f, sizeof(f));
    cin>>n>>m>>q;
    for(int i=0; i<m; i++)
    {
        int u, v;
        long long w;
        cin>>u>>v>>w;
        f[u][v] = f[v][u] = min(w, f[u][v]); //
    }
    floyd(); //漏了这个：调用函数
    //开始输出
    int start, end;
    for(int i=0; i<q; i++)
    {
        cin >> start >> end;
        if(f[start][end] == INF)
            cout << -1 << endl;
        else if(start == end)
            cout << 0 << endl;
        else
            cout << f[start][end] << endl;
    }
    return 0;
}

2024/04/04        周四

出差（Bellman-ford算法）

题目链接

【参考代码】

#include <bits/stdc++.h>
using namespace std;

const int INF = 0x3f3f3f3f;
const int N = 20001; //需要存储双向边，10000*2

struct node
{
    int start; //起点
    int end; //终点
    int RoutineTime; //该路线所需时间
}edge[N];

int LsolationTime[N]; //隔离时间
int ShortDistanceTime[N];

int main()
{
    int n, m, u, v, c;
    cin>>n>>m;
    for(int i=1; i<=n; i++)
    {
        cin>>LsolationTime[i];
    }   
    for(int i=1; i<=m; i++)
    {
        cin>>u>>v>>c;
        edge[i].start = u;
        edge[i].end = v;
        edge[i].RoutineTime = c;
        edge[m+i].start = v;
        edge[m+i].end = u;
        edge[m+i].RoutineTime = c;
    }
    
    memset(ShortDistanceTime, INF, sizeof(ShortDistanceTime));
    ShortDistanceTime[1] = 0; //起点距离为0
    for(int operation = 1; operation <= n; operation++) //循环n轮
    {
    	for(int i=1; i<=2*m; i++)
    	{
    		u = edge[i].start; //当前点
    		v = edge[i].end;  //邻居
    		int time = LsolationTime[v]; //邻居点隔离时间
    		if(v == n) //到达终点
    			time = 0;
    		//到邻居所需时间=当前点+路线时间+隔离时间
    		ShortDistanceTime[v] = 
            min(ShortDistanceTime[v], ShortDistanceTime[u] + edge[i].RoutineTime + time);
		}
	}
	cout << ShortDistanceTime[n] << endl;
    return 0;
}

2024/04/05        周五

蓝桥王国（Dijkstra算法）

题目链接

【参考代码】

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const ll INF = 0x3f3f3f3f3f3f3fLL;
const int N = 3e5+1;
int n, m;

struct edge{
    int from;
    int to;
    ll weight;
    edge(int num1, int num2, ll num3) //构造函数，用于给变量赋值。错误点：ll写成int
    {
        from = num1;
        to = num2;
        weight = num3;
    }
};

vector<edge> e[N];
ll ShortDistance[N];

struct node{
    int id;  //结点
    ll nowdistance; //这个结点到起点的距离
    node(int num1, ll num2) //构造函数，用于给变量赋值。错误点：ll写成int
    {
        id = num1;
        nowdistance = num2;
    }
    bool operator < (const node &a) const
    {
        return nowdistance > a.nowdistance;
    }
};

void dijkstra()
{
    bool done[N]; // done[i]=true表示到结点i的最短路径已经找到
    for(int i=1;i<=n;i++)
    {
        ShortDistance[i] = INF; // 对最小距离数组进行初始化
        done[i] = false; // 对标记数组进行初始化
    }
    ShortDistance[1] = 0; // 起点到自己的距离是0
    priority_queue<node> q;
    q.push(node(1, 0));
    while(!q.empty())
    {
        node dot = q.top();
        q.pop();
        if(done[dot.id])
            continue;
        done[dot.id] = true;
        for(int i=0; i<e[dot.id].size(); i++)
        {
            edge neighbor = e[dot.id][i]; //这里的 e[u.id] 是一个存储边信息的向量（vector），它包含了所有从节点 u 出发的边。e[u.id][i] 表示取出向量中的第 i 个元素，即从节点 u 到节点 y.to 的边的信息。
            if(done[neighbor.to])
                continue;
            if(ShortDistance[neighbor.to] > neighbor.weight + dot.nowdistance) //更新距离值
            {
                ShortDistance[neighbor.to] = neighbor.weight + dot.nowdistance;
                q.push(node(neighbor.to, ShortDistance[neighbor.to]));
            }
        }
    }
}

int main()
{
    int u, v, w;
    cin>>n>>m;
    for(int i=1; i<=n; i++)
        e[i].clear();
    while(m--)
    {
        cin>>u>>v>>w;
        e[u].push_back(edge(u, v, w)); //将边添加到正确的容器中
    }
    dijkstra();
    for(int i=1; i<=n; i++)
    {
        if(ShortDistance[i] >= INF) //无法到达
            cout << -1 << ' ';
        else
            cout << ShortDistance[i] << ' ';
    }
    return 0;
}

子树的大小

题目链接

【参考代码】

#include <iostream>
using namespace std;
typedef long long ll;

int main()
{
  int t;
  cin>>t;
  while(t--)
  {
      ll n, m, k; //n个结点，m茶树，第k点
      cin>>n>>m>>k;
      ll ans = 1;
      ll leftchild = (k - 1) * m + 2;
      ll rightchild = k * m + 1;
      while(rightchild <= n)
      {
          ans += rightchild - leftchild + 1; //加回本身的点
          leftchild = (leftchild - 1) * m + 2; //leftchild继续增加
          rightchild = rightchild * m + 1; //rightchild继续增加
      }
      if(leftchild <= n)
      {
          ans += n - leftchild + 1;
      }    
      cout << ans << endl;
  }
  return 0;
}

平均

题目链接

【参考代码】

#include <bits/stdc++.h>
using namespace std;

const int N = 1e5;

struct node
{
    int number;
    int weight;
}a[N];

bool compare(node num1, node num2) //按代价升序排列
{
    return num1.weight < num2.weight;
}

int main()
{
    int n;
    long long value = 0;
    int hash[10] = {0}; //0-9出现的次数
    cin>>n;
    for(int i=0; i<n; i++)
    {
        cin>>a[i].number>>a[i].weight;
        hash[a[i].number]++;
    }
    sort(a, a+n, compare); //按代价升序排列
    for(int i=0; i<n; i++) //从最小代价开始找，不管number，number的出现次数已经存好了
    {
        if(hash[a[i].number] > n / 10) //题目规定的出现次数，每个数只能出现n/10次
        {
            value += a[i].weight; //加上这个数的代价
            hash[a[i].number]--; //该数出现的次数减一次
        }
    }
    cout << value << endl;
    return 0;
}

ASC

题目链接

【参考代码】

#include <iostream>

using namespace std;

int main()

{

    cout << 'L'-'A'+'A' << endl;

    return 0;

}

不同子串

题目链接

【参考代码】

这题比较坑的是第二重循环需要从0开始

最终结果：100

set容器，不需要赋值

#include <bits/stdc++.h>
using namespace std;

set<string> s1;

int main()
{
    string s = "0100110001010001";
    for(int i=0; i<s.size(); i++)
    {
        for(int j=0; j<s.size(); j++) //需要从0开始，无需担心重复
        {
            s1.insert( s.substr(i, j) );
        }
    }
    cout << s1.size() << endl;
    return 0;
}

map容器，需要赋值

#include <bits/stdc++.h>
using namespace std;

map<string, int> mp;

int main()
{
    string s = "0100110001010001";
    for(int i=0; i<s.size(); i++)
    {
        for(int j=0; j<s.size(); j++)
        {
            mp[s.substr(i, j)] = 1;
        }
    }
    cout << mp.size() << endl;
    return 0;
}

星期计算

题目链接

【参考代码】

20^{22}爆long long，long long范围在10^{18}

你也可以用__int128

#include <iostream>
using namespace std;

int main()
{
    int ans = 6;
    long long temporary = 1;
    for(int i=0; i<22; i++)
    {
        temporary *= 20;
        temporary %= 7;  
    }
    ans += temporary;
    ans %= 7;
    cout << ans+7 << endl;
    return 0;
}

__int128版本：

#include <bits/stdc++.h>
using namespace std;

int main()
{
    int ans = 6;
    __int128 temporary = 1;
    for(int i=0; i<22; i++)
    {
        temporary *= 20;
    }
    temporary = temporary % 7;
    ans = ans + temporary;
    cout << ans << endl;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1577400.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

如何本地搭建Discuz论坛并实现无公网IP远程访问

如何本地搭建Discuz论坛并实现无公网IP远程访问

文章目录 前言1.安装基础环境2.一键部署Discuz3.安装cpolar工具4.配置域名访问Discuz5.固定域名公网地址6.配置Discuz论坛 前言 Crossday Discuz! Board&#xff08;以下简称 Discuz!&#xff09;是一套通用的社区论坛软件系统&#xff0c;用户可以在不需要任何编程的基础上&a…
阅读更多...
基于velero和minio实现k8s数据的备份

基于velero和minio实现k8s数据的备份

1.30部署minio rootk8s-harbor:/etc/kubeasz/clusters/k8s-cluster1# docker run \ -d --restartalways -p 9000:9000 -p 9090:9090 –name minio -v /data/minio/data:/data -e “MINIO_ROOT_USERadmin” -e “MINIO_ROOT_PASSWORD12345678” quay.io/minio/minio server…
阅读更多...
Golang | Leetcode Golang题解之第9题回文数

Golang | Leetcode Golang题解之第9题回文数

题目&#xff1a; 题解&#xff1a; func isPalindrome(x int) bool {// 特殊情况&#xff1a;// 如上所述&#xff0c;当 x < 0 时&#xff0c;x 不是回文数。// 同样地&#xff0c;如果数字的最后一位是 0&#xff0c;为了使该数字为回文&#xff0c;// 则其第一位数字也…
阅读更多...
2024Spring＞ HNU-计算机系统-实验2-datalab-导引

2024Spring＞ HNU-计算机系统-实验2-datalab-导引

前言 datalab考验对于位运算以及浮点数存储的理解&#xff0c;如果真的肯花时间去搞懂&#xff0c;对计算机系统存储的理解真的能上一个台阶。与课程考试关联性上来说不是很大&#xff0c;但对于IEEE的浮点数表示一定要熟练掌握。 导引 ①实验工具包 要完成的是bits.c中的15个…
阅读更多...
Java | Leetcode Java题解之第13题罗马数字转整数

Java | Leetcode Java题解之第13题罗马数字转整数

题目&#xff1a; 题解&#xff1a; class Solution {Map<Character, Integer> symbolValues new HashMap<Character, Integer>() {{put(I, 1);put(V, 5);put(X, 10);put(L, 50);put(C, 100);put(D, 500);put(M, 1000);}};public int romanToInt(String s) {int …
阅读更多...
Linux中shell脚本的学习第一天，编写脚本的规范，脚本注释、变量，特殊变量的使用等，包含面试题

Linux中shell脚本的学习第一天，编写脚本的规范，脚本注释、变量，特殊变量的使用等，包含面试题

4月7日没参加体侧的我自学shell的第一天 Shebang 计算机程序中&#xff0c;shebang指的是出现在文本文件的第一行前两个字符 #&#xff01; 1)以#!/bin/sh 开头的文件&#xff0c;程序在执行的时候会调用/bin/sh, 也就是bash解释器 2)以#!/usr/bin/python 开头的文件&#…
阅读更多...
Qt通讯录管理系统

Qt通讯录管理系统

在git上面找的一个操作文件的qt通讯录管理系统,尝试将它复刻了一下. 成果展示 分两个txt文件存储,一个是手机联系人,一个是电话卡联系人,主要功能就是增删改查,主要使用的是OOP的编程思想. 实现过程 界面布局 考虑设计三个界面,主界面,添加联系人界面和修改联系人的界面.于是添…
阅读更多...
深入理解nginx realip模块[上]

深入理解nginx realip模块[上]

目录 1. 引言2. Real IP模块的使用2.1 启用Real IP模块2.2 配置Real IP模块2.2.1 配置指令2.2.2 举例 3. 变量的使用 深入理解nginx realip模块[上] 深入理解nginx realip模块[下] 1. 引言 nginx 的 Real IP 模块用于解决代理服务器转发请求到nginx上时可能出现的 IP 地址问题…
阅读更多...
ES入门十一：正排索引和倒排索引

ES入门十一：正排索引和倒排索引

索引本质上就是一种加快检索数据的存储结构&#xff0c;就像书本的目录一下。 为了更好的理解正排索引和倒排索引&#xff0c;我们借由一个 **唐诗宋词比赛&#xff0c;**这个比赛一共有两个项目&#xff1a; 给定诗词名称&#xff0c;背诵整首给诗词中几个词语&#xff0c;让…
阅读更多...
lua学习笔记6（经典问题输出99乘法表）

lua学习笔记6（经典问题输出99乘法表）

print("************for循环的99乘法表*************") for i 1, 9 dolocal line "" -- 创建一个局部变量来累积每行的输出--local 是一个关键字&#xff0c;用于声明一个局部变量。for j 1, i doline line .. j .. "*" .. i .. ""…
阅读更多...
mysql查询时大小写，末尾空格容易造成的问题。

mysql查询时大小写，末尾空格容易造成的问题。

问题描述 在使用mysql innodb 默认的配置时&#xff0c;发现mysql查询时是忽略大小写和末尾空格的。 示例 比如下面的查询&#xff1a;查询条件中是大写的字母&#xff0c;末尾也没有空格。但是查询出的结果中&#xff0c;既有小写的&#xff0c;也有末尾带有空格的&#xf…
阅读更多...
Windows Edge浏览器的兼容性问题及解决方案

Windows Edge浏览器的兼容性问题及解决方案

1、Windows Edge&#xff08;了解 Microsoft Edge&#xff09;&#xff1a; 简单介绍&#xff1a; Microsoft Edge是一款由微软开发的网页浏览器&#xff0c;最初于2015年伴随Windows 10推出&#xff0c;作为Internet Explorer的继任者&#xff0c;旨在提供更快、更安全、更现代…
阅读更多...
二维相位解包理论算法和软件【全文翻译- 掩码（3.4）】

二维相位解包理论算法和软件【全文翻译- 掩码（3.4）】

本节我们将研究从质量图中提取掩码的问题。掩码是一个质量图，其像素只有两个值：0 或 1。零值像素标志着质量最低的相位值，这些相位值将被屏蔽、零权重或忽略。第 5 章中的某些 L/ 正则算法需要使用掩码来定义零权重。掩码还可用于某些路径跟踪算法，如第 4.5 节中将要介绍的…
阅读更多...
Linux：安装zabbix-agent被监控端（2）

Linux：安装zabbix-agent被监控端（2）

本章是结合着上一篇文章的续作 Linux&#xff1a;部署搭建zabbix6&#xff08;1&#xff09;-CSDN博客https://blog.csdn.net/w14768855/article/details/137426966?spm1001.2014.3001.5501本章将在两台centos部署agent端&#xff0c;然后使用server进行连接监控 agent1 在1…
阅读更多...
PostgreSQL技术内幕（十五）：深度解析PG事务管理和分布式事务

PostgreSQL技术内幕（十五）：深度解析PG事务管理和分布式事务

PostgreSQL技术内幕&#xff08;十五&#xff09;&#xff1a;深度解析PG事务管理和分布式事务 事务作为保障数据完整性和一致性的关键机制&#xff0c;在数据库操作中扮演着举足轻重的角色。事务通过将一系列逻辑上的操作捆绑在一起&#xff0c;确保它们要么全部成功执行&…
阅读更多...
IPD集成项目管理：继电器供应商宏发股份上线奥博思 PowerProject 项目管理系统平台

IPD集成项目管理：继电器供应商宏发股份上线奥博思 PowerProject 项目管理系统平台

厦门宏发电声股份有限公司&#xff08;以下简称“宏发股份”&#xff09;签约北京奥博思软件公司&#xff0c;选择PowerProject建设全生命周期数字化项目管理平台。 了解奥博思项目管理软件&#xff1a;http://www.powerproject.com.cn/ 宏发股份项目管理系统启动会顺利召开 …
阅读更多...
rsync-远程同步备份

rsync-远程同步备份

目录 前言 一、rsync远程同步概述 1、rsync远程同步概念 2、rsync功能及特点 3、rsync的备份方式 4、rsync的上下行同步方式 4.1 下行同步 4.2 上行同步 5、rsyncinotify 6、rsync同类服务 7、rsync与cp、scp对比 二、rsync命令 1、rsync格式语法 2、rsync配置同…
阅读更多...
Clarity AI：免费开源的AI无损图片放大图像升级器和增强工具

Clarity AI：免费开源的AI无损图片放大图像升级器和增强工具

可以作为Magnific AI的平替版本。Magnific AI是一款基于人工智能技术的图像处理工具&#xff0c;主要功能包括图像放大、像素级AI重绘、灵活的设置调整以及多种优化场景。它能够支持最高放大至16倍&#xff0c;甚至可以达到1亿像素的分辨率。此外&#xff0c;Magnific AI还具备…
阅读更多...
MySQL中数据库、表的操作

MySQL中数据库、表的操作

文章目录 一、管理数据库1.1、连接数据库1.2、创建库1.3、选择数据库1.4、修改数据库名称1.5、查看数据库信息1.6、删除库 二、定义数据表字段2.1、数据表字段的数据类型2.2、数据表字段属性2.3、约束讲解2.3.1、约束的定义1&#xff09;为什么需要约束2&#xff09;什么是约束…
阅读更多...
敏感信息泄露漏洞

敏感信息泄露漏洞

法律声明 参与培训需要遵守国家法律法规&#xff0c;相关知识只做技术研究&#xff0c;请勿用于违法用途&#xff0c;造成任何后果自负与本人无关。 中华人民共和国网络安全法&#xff08;2017年6月1日起施行&#xff09; 第二十二条 任何个人和组织不得从事入侵他人网络、干扰…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023