2021-03-11

最新推荐文章于 2024-10-08 09:44:01 发布
最新推荐文章于 2024-10-08 09:44:01 发布
阅读量129 收藏
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jingeche/article/details/114651116
版权

https://blog.csdn.net/qq_35034604/article/details/107959429?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-14.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-14.control

#include <iostream>
#include <vector>
#include "string"
using namespace std;
//构造一个二维数组
//对于一个子串而言，如果它是回文串，并且长度大于 22，那么将它首尾的两个字母去除之后，它仍然是个回文串。例如对于字符串ababa
//根据这样的思路，我们就可以用动态规划的方法解决本题。我们用 P(i,j)P(i,j) 表示字符串s的第 i 到 j 个字母组成的串（下文表示成 s[i:j]s[i:j]）是否为回文串：
//P[i,j] = true，表示s[i]-s[j]是回文串.其他情况P[i,j] = false，这里其他情况表示s[i]-s[j]不是回文串或者s[i]到s[j]不合法
//动态规划的状态转移方程：P(i, j) = P(i+1, j-1) && (S[i] == S[j])
//也就是说，只有 s[i+1:j-1]是回文串，并且s[i]==s[j]时才是回文串。
//上文的所有讨论是建立在子串长度大于2，我们还需要考虑动态规划中的边界条件，即子串的长度为1或2。1或2拿出来单独判断。
//我们可以这么推导，P(i,i)=true P(i,i+1)=(S[i]==S[i+1]
//根据这个思路，我们就可以完成动态规划了，最终的答案即为所有 P(i, j) ==true 中 j-i+1的最大值。
// 注意：在状态转移方程中，我们是从长度较短的字符串向长度较长的字符串进行转移的，因此一定要注意动态规划的循环顺序。

std::string longestPalindrome(std::string s) {
    if ( s.empty() ) {
        return "";
    }
    int n = s.size();
    std::vector<std::vector<bool>> dp(n, std::vector<bool>(n, false));

    int maxLen = 0;
    string maxStr = "";
    for (int j = 0; j < n; ++j ) {
        for (int i = j; i >= 0; --i) {
            if (i == j) {
                dp[i][j] = true;
            }
            else if (i == j - 1) {
                dp[i][j] = dp[i + 1][j] && s[i] == s[j];
            }
            else {
                dp[i][j] = dp[i + 1][j - 1] && s[i] == s[j];
            }

            if ( dp[i][j] && maxLen < j - i +1 ) {
                maxLen = j - i + 1;
                maxStr =  s.substr(i, maxLen);
            }
        }
    }

    return maxStr;
}

int main() {
    string str = "ababba" ;
    string substr = longestPalindrome(str);
    cout<<substr;
    return 0;
}

 

 

//题目：输入一个正整数数组，将它们连接起来排成一个数，输出能排出的所有数字中最大的一个。
//例如输入数组{32,  321}，则输出这两个能排成的最大数字32321.。
//或者输入数组{10,9,33,1000}输出这四个能排列的最大数字933101000.
#include <iostream>
#define MAXSIZE 100
using namespace std;

template<typename T>
class Grial
{
public:
    int Length(int x,int& n)
    {
        n++;
        (x/10)&& (Length(x/=10,n));
        return n;
    }//求数字的位数。
    bool Complate(int x,int y)//比较x,y的大小，是组合排列大小，看xy比yx的大小，从而好形成大堆。
    {
        int _I = 0;
        int i = 0;
        int j = 0;
        int sum_1=x;
        int sum_2=y;
        Length(x,i);
        Length(y,j);
        for(;_I<j;_I++)
        {
            sum_1*=10;
        }
        for(_I=0;_I<i;_I++)
        {
            sum_2*=10;
        }
        if((sum_1+y)>(sum_2+x))return true;
        else
            return false;
    }
    Grial(T a[],int n)
    {
        data = new  T[n];
        size = n;
        for(int i=0;i<n;i++)
        {
            data[i] = a[i];
        }
        int m = size/2;
        while(m<size)
        {
            MaxSort(m);
            m++;
        }
    }
    void MaxSort(int n)//大堆排列
    {
        int temp;
        int i=n;
        int j=(i-1)/2;
        while(i>0)
        {
            if(!Complate(data[j],data[i]))
            {
                temp = data[i];
                data[i]=data[j];
                data[j]=temp;
            }
            i = j;
            j = (i-1)/2;
        }
    }
    int GetTop()//得到大堆第一个元素,并且将最后面一个元算放在下标为0的位置，再进行大堆排序.
    {
        if(size==0)return -1;
        int temp = data[0];
        data[0] = data[size-1];
        size--;
        int m = size/2;
        while(m<size)
        {
            MaxSort(m);
            m++;
        }
        return temp;
    }
    void GetSum()
    {
        int i = GetTop();
        if(i!=-1)
        {
            cout<<i;
            GetSum();
        }
    }
private:
    T *data;
    int size;
};
int main()
{
    int a[]={22,223};
    Grial<int> G(a,2);
    G.GetSum();
    cout<<endl;
    return 0;
}

 

 

 

#include <iostream>
#include <vector>
#include "string"
using namespace std;
//构造一个二维数组
//对于一个子串而言，如果它是回文串，并且长度大于2，那么将它首尾的两个字母去除之后，它仍然是个回文串。例如对于字符串ababa，bab也是一个回文串
//根据这样的思路，我们就可以用动态规划的方法解决本题。我们用 P(i,j)表示字符串s的第i到j个字母组成的串是否为回文串：
//P[i,j] = true，表示s[i]-s[j]是回文串.其他情况P[i,j] = false，这里其他情况表示s[i]-s[j]不是回文串或者s[i]到s[j]不合法
//动态规划的状态转移方程：P(i, j) = P(i+1, j-1) && (S[i] == S[j])
//也就是说，只有 s[i+1:j-1]是回文串，并且s[i]==s[j]时才是回文串。
//上文的所有讨论是建立在子串长度大于2，我们还需要考虑动态规划中的边界条件，即子串的长度为1或2。1或2拿出来单独判断。
//我们可以这么推导，P(i,i)=true，然后从0开始探索当前子串的回文串的长度，对比最长的字串。最终的答案即为所有 P(i, j) ==true 中 j-i+1的最大值。

std::string longestPalindrome(std::string s) {
    if ( s.empty() ) {
        return "";
    }
    int n = s.size();
    std::vector<std::vector<bool>> dp(n, std::vector<bool>(n, false));

    int maxLen = 0;
    string maxStr = "";
    for (int j = 0; j < n; ++j ) {
        for (int i = j; i >= 0; --i) {
            if (i == j) {
                dp[i][j] = true;
            }
            else if (i == j - 1) {
                dp[i][j] = dp[i + 1][j] && s[i] == s[j];
            }
            else {
                dp[i][j] = dp[i + 1][j - 1] && s[i] == s[j];
            }

            if ( dp[i][j] && maxLen < j - i +1 ) {
                maxLen = j - i + 1;
                maxStr =  s.substr(i, maxLen);
            }
        }
    }

    return maxStr;
}

int main() {
    string str = "ababba" ;
    string substr = longestPalindrome(str);
    cout<<substr;
    return 0;
}

 

 

 

/题目描述：一个链表，奇数位升序偶数位降序，让链表变成升序的。
//
//比如：1 8 3 6 5 4 7 2 9，最后输出1 2 3 4 5 6 7 8 9
//
//这道题目可以分为三个步骤，
//一：对链表按照奇偶划分，分为一个升序链表 一个降序链表
//二：翻转降序链表
//三：合并两个升序链表

//代码如下：
#include <bits/stdc++.h>
using namespace std;
struct node{
    node * next;
    int val;
    node(int v):val(v), next(NULL){};
};
node * constructList(int *a, int size)
{
    node head(0);
    node * h = &head;
    for(int i=0;i<size;i++)
    {
        h->next = new node(a[i]);
        h = h->next;
    }
    return head.next;
}

void splitList(node * head, node * even, node * odd)
{
    node * e = even;
    node * o = odd;

    int index = 0;
    while(head)
    {
        if(index%2==0)
        {
            e->next = new node(head->val);
            e = e->next;
        }
        else {
            o->next = new node(head->val);
            o = o->next;
        }
        index++;
        head = head->next;
    }
}
node * reverseList(node * head)
{
    node * pre = NULL;
    node * cur = head;
    while(cur)
    {
        node * temp =  cur->next;
        cur->next = pre;
        pre = cur;
        cur = temp;
    }
    return pre;
}
node * mergeList(node * h1, node * h2)
{
    node head(0);
    node * h = &head;
    while(h1 && h2)
    {
        if(h1->val < h2->val)
        {
            h->next = h1;
            h1 = h1->next;
        }
        else {
            h->next = h2;
            h2 = h2->next;
        }
        h = h->next;
    }
    if(!h1) h->next = h2;
    else h->next = h1;
    return head.next;
}
int main()
{
    int num[] = {1,20,2,18,3,16,4,5,5,3,7,2};
    node * h1 = constructList(num,12);
    node even(0);
    node odd(0);
    node * e = &even;
    node * o = &odd;
    splitList(h1, e, o);
    node * ecopy = e->next;
    while(ecopy)
    {
        cout << ecopy->val <<  " ";
        ecopy = ecopy->next;
    }
    cout << "e" << endl;
    node * ocopy = o->next;
    while(ocopy)
    {
        cout << ocopy->val << " ";
        ocopy = ocopy->next;
    }
    cout << "o" << endl;

    node * h2 = reverseList(o->next);
    node * h3 = mergeList(e->next, h2);
    while(h3)
    {
        cout << h3->val << " ";
        h3 = h3->next;
    }

    return 0;
}
#include <atomic>
#include <condition_variable>
#include <functional>
#include <memory>
#include <mutex>
#include <queue>

template <class T>

class CQueue
{
protected:
    // Data
    std::queue<T> _queue;   ///< 存储数据的真实队列, 不是线程安全的
private:
    typename std::queue<T>::size_type _size_max;    ///< 队列的最大长度
    // Thread gubbins
    std::mutex _mutex;  ///<  线程操作 锁
    std::condition_variable _fullQue;   ///< 队列满了的信号
    std::condition_variable _empty; ///< 队列为空的信号

    // Exit
    // 原子操作
    std::atomic_bool _quit; ///< { false };     // 退出信号
    std::atomic_bool _finished; ///< { false }; // 完成信号 // 表示不再继续输入数据

public:
    //初始化队列
    CQueue(const size_t size_max) :_size_max(size_max) {
        _quit = ATOMIC_VAR_INIT(false);
        _finished = ATOMIC_VAR_INIT(false);
    }

    ~CQueue()
    {
        Quit();
        while (_queue.size())
            ;
    }
    //队列中加入新的 对象  根据情况决定 满信号之后 新数据丢弃或者等待
    bool Push(T& data)
    {
        std::unique_lock<std::mutex> lock(_mutex);
        while (!_quit && !_finished)
        {
            if (_queue.size() < _size_max)
            {
                _queue.push(std::move(data));
                //_queue.Push(data);
                _empty.notify_all();
                return true;
            }
            else
            {
                // wait的时候自动释放锁，如果wait到了会获取锁
                _fullQue.wait(lock);
                // return false;   ///< 如果满了 这里不进行等待 避免出现问题
            }
        }

        return false;
    }

    //返回队列最前面的元素 并且弹出
    //如果空 如果finish 则直接返回fasle 否则 等待队列加入元素
    bool Pop(T &data)
    {
        std::unique_lock<std::mutex> lock(_mutex);
        while (!_quit)
        {
            if (!_queue.empty())                // 队列非空
            {
                //data = std::move(_queue.front());
                data = _queue.front();
                _queue.pop();

                _fullQue.notify_all();       // 通知所有 由于满队无法加入的线程
                return true;
            }
            else if (_queue.empty() && _finished)   // 队列为空 且不再加入
            {
                return false;
            }
            else
            {
                // _empty.wait(lock);          // 等待队列加入元素
                return false;   ///< 不等待元素加入数据
            }
        }
        return false;
    }

    /**
     * @fn  std::shared_ptr<T> CQueue::Pop(void)
     *
     * @brief   弹出一个元素 直接返回  出错无法报错
     *
     * @author  IRIS_Chen
     * @date    2019/10/14
     *
     * @return  The previous top-of-stack object.
     */

    std::shared_ptr<T> Pop(void)
    {
        std::unique_lock<std::mutex> lock(_mutex);
        std::shared_ptr<T> res = nullptr;
        while (!_quit)
        {
            if (!_queue.empty())                // 队列非空
            {
                //data = std::move(_queue.front());
                res = std::make_shared<T>(_queue.front());
                _queue.pop();

                _fullQue.notify_all();       // 通知所有 由于满队无法加入的线程

                return res;
            }
            else if (_queue.empty() && _finished)   // 队列为空 且不再加入
            {
                return res;     // 无数据进入 智能返回一个空指针 (可能出错)
            }
            else
            {
                _empty.wait(lock);          // 等待队列加入元素
            }
        }
        return false;
    }

    /**
     * @fn  void CQueue::Finished()
     *
     * @brief   The queue has Finished accepting input 标识队列完成输入 不再继续输入
     *
     * @author  IRIS_Chen
     * @date    2019/10/14
     */

    void Finished()
    {
        _finished = true;
        _empty.notify_all();
    }

    void Quit()
    {
        _quit = true;
        _empty.notify_all();
        _fullQue.notify_all();
    }

    int Length()
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return static_cast<int>(_queue.size());
    }
    int Size()
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return static_cast<int>(_queue.size());
    }


    bool Empty(void)
    {
        std::unique_lock<std::mutex> lock(_mutex);
        return (0 == _queue.size());
    }

    bool Clear(void)
    {
        std::unique_lock<std::mutex> lock(_mutex);
        while (!_queue.empty ())
        {
            Pop();  // 依次弹出数据
        }
        return true;
    }
};
xiannvlei
关注
专栏目录
2021-03-17
m0_56206427的博客
03-17 1404
如何在阿里云服务器部署项目，用到阿里的负载均衡服务，查了一些资料。由此记录一下，方便以后再次使用： 第一步：创建负载均衡实例官方教程链接：创建负载均衡实例点击创建负载均衡实例，选择负载均衡规格，输入实例名称(给负载均衡起个小名)，点击去购买，对勾购买协议，点击去开通。![这两天准备在阿里云服务器部署项目，用到阿里的负载均衡服务，查了一些资料。由此记录一下，方便以后再次使用： 第一步：创建负载均衡实例 官方教程链接：创建负载均衡实例 点击创建负载均衡实例，选择负载均衡规格，输入实例名称（给负载均衡起个小名儿）
2021-11-04
m0_53575762的博客
11-20 7216
一、Linux命令和windows区别？ 1、Linux命令全部严格区分大小写；而windows命令大小写都识别。 2、Linux所有的文件都是没有扩展名的，而windows是文件是有扩展名的。 创建一个新用户 [root@localhost mxh]# useradd mxh2 # 创建一个user [root@localhost mxh]# password mxh2 #12345678 [root@localhost xxx]# gr...
数据结构实验之链表四：有序链表的归并
weixin_34055787的博客
01-22 506
题目描述 分别输入两个有序的整数序列（分别包含M和N个数据），建立两个有序的单链表，将这两个有序单链表合并成为一个大的有序单链表，并依次输出合并后的单链表数据。 输入 第一行输入M与N的值； 第二行依次输入M个有序的整数；第三行依次输入N个有序的整数。 输出 输出合并后的单链表所包含的M+N个有序的整数。 示例输入 6 5 1 23 26 45 66 99 14 21 28 ...
2021-03-15
weixin_44902539的博客
03-15 1283
好网站 https://blog.csdn.net/u013317445/article/details/88196373?utm_medium=distribute.pc_relevant.none-task-blog-OPENSEARCH-6.control&dist_request_id=1328641.48931.16157665162059593&depth_1-utm_source=distribute.pc_relevant.none-task-blog-OPENSEARCH-
2021-03-05
qq_37122159的博客
03-05 803
2021-02-03
qq_37135047的博客
02-03 1127
/** * 隐藏虚拟按键，并且全屏 */ protected void hideBottomUIMenu() { //隐藏虚拟按键，并且全屏 if (Build.VERSION.SDK_INT > 11 && Build.VERSION.SDK_INT < 19) { // lower api View v = this.getWindow().getDecorView(); ...
CVE-2021-22205——Gitlab 远程命令执行漏洞复现
LiBai'S BLOG
11-10 9243
CVE-2021-22205Vuln Impact影响版本环境Fofa语法漏洞利用脚本反弹ShellEXP Vuln Impact An issue has been discovered in GitLab CE/EE affecting all versions starting from 11.9. GitLab was not properly validating image files that were passed to a file parser which resulted in a .
CVE-2021-41277——Metabase 信息泄露漏洞
热门推荐
LiBai'S BLOG
11-21 1万+
Metabase 信息泄露漏洞漏洞简介FOFA语法EXP漏洞测试漏洞修复 漏洞简介 Metabase是美国Metabase公司的一个开源数据分析平台。 Metabase 中存在信息泄露漏洞，该漏洞源于产品的 admin-＞settings-＞maps-＞custom maps-＞add a map 操作缺少权限验证。攻击者可通过该漏洞获得敏感信息。 CNNVD编号：CNNVD-202111-1565 危害等级： 超危 CVE编号： CVE-2021-41277 FOFA语法 app="Metabase
2021-01-15
hikarilee的博客
01-15 1282
git clone 操作出现 fatal:index-pack failed 此错误为当前克隆文件夹属性只读，将只读取消
UC浏览器开发者版本下载.2021-03-11
慕容雪羽
03-11 2439
下载地址: https://dev.ucweb.com/download/ 另附一个安卓版的x86 play商店版,这x86版本绝版了 https://www.52pojie.cn/thread-1227505-1-1.html
eclipse-java-2021-03-R-win32-x86_64.zip
03-24
Eclipse 2021-03-R 版本是该IDE的一个重要更新，提供了最新的功能和性能优化，尤其对于Windows x86_64架构的支持。 1. **Eclipse IDE**: Eclipse是一款开源的多语言开发平台，由Eclipse基金会维护。它基于插件架构...
eclipse-embedcpp-2021-03-R-win32-x86_64.zip
03-24
这个版本是"2021-03-R"，表明它是2021年3月发布的更新版本，适用于Windows 64位操作系统。Eclipse IDE的这个版本提供了丰富的工具和功能，帮助开发者高效地编写、调试和优化嵌入式应用。 首先，Eclipse IDE的核心...
eclipse-committers-2021-03-R-win32-x86_64.zip
04-11
"eclipse-committers-2021-03-R-win32-x86_64.zip" 文件是Eclipse针对2021年3月发布的一个特定版本，特别为Windows 10 64位操作系统优化。这个版本被称为"Eclipse 2021-03"，"R"代表它是一个正式发布（Release）版本...
eclipse-jee-2021-03-R-win32-x86_64
03-19
本压缩包"eclipse-jee-2021-03-R-win32-x86_64"是专为Windows 32位x86_64架构设计的Eclipse IDE版本，主要针对Java企业级应用开发（Java EE）。 Eclipse JEE版包含了开发Web和企业应用程序所需的各种工具和插件。...
日志文件2021-03-11&12
03-12
标题"日志文件2021-03-11&12"表明我们处理的是两天的日志数据，即2021年3月11日和12日的记录。这些日志可能来自服务器、网络设备、应用程序或者操作系统，用于后期分析、故障排查和性能优化。 日志文件通常以文本...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1283
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
【C++】List
最新发布
m0_46676283的博客
10-08 311
文章目录1.list的介绍及使用1.1 list的介绍 本节目标 1.list的介绍及使用 2.list的深度剖析及模拟实现 3.list与vector的对比 4.本节习题 1.list的介绍及使用 1.1 list的介绍
（STL）map与set的封装--采用红黑树
2302_80190394的博客
10-04 830
（STL）map与set的封装--采用红黑树
C++之多态篇(超详细版)
2302_79795375的博客
10-04 900
public:cout
embedcpp-2021-03
10-06
embedcpp-2021-03是一个有关嵌入式C++编程的课程，于2021年3月举办。嵌入式C++编程是指在嵌入式系统中使用C++编程语言进行开发的一种方法。 在嵌入式系统中，资源通常是有限的，例如处理器速度、内存容量和存储空间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值