findres.cpp

  name="google_ads_frame" marginwidth="0" marginheight="0" src="http://pagead2.googlesyndication.com/pagead/ads?client=ca-pub-5572165936844014&dt=1194442938015&lmt=1194190197&format=336x280_as&output=html&correlator=1194442937843&url=file%3A%2F%2F%2FC%3A%2FDocuments%2520and%2520Settings%2Flhh1%2F%E6%A1%8C%E9%9D%A2%2FCLanguage.htm&color_bg=FFFFFF&color_text=000000&color_link=000000&color_url=FFFFFF&color_border=FFFFFF&ad_type=text&ga_vid=583001034.1194442938&ga_sid=1194442938&ga_hid=1942779085&flash=9&u_h=768&u_w=1024&u_ah=740&u_aw=1024&u_cd=32&u_tz=480&u_java=true" frameborder="0" width="336" scrolling="no" height="280" allowtransparency="allowtransparency"> 
#include <windows.h> 
#include "FindRes.h"


#if defined (WIN32)
 #define IS_WIN32 TRUE
#else
 #define IS_WIN32 FALSE
#endif

#define IS_NT      IS_WIN32 && (BOOL)(GetVersion() < 0x80000000)
#define IS_WIN32S  IS_WIN32 && (BOOL)(!(IS_NT) && (LOBYTE(LOWORD(GetVersion()))<4))
#define IS_WIN95   (BOOL)(!(IS_NT) && !(IS_WIN32S)) && IS_WIN32

HINSTANCE hInst;   // current instance

LPCTSTR lpszAppName  = "MyApp";
LPCTSTR lpszTitle    = "My Application";

BOOL RegisterWin95( CONST WNDCLASS* lpwc );

int APIENTRY WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
                      LPTSTR lpCmdLine, int nCmdShow)
{
   MSG      msg;
   HWND     hWnd;
   WNDCLASS wc;

   // Register the main application window class.
   //............................................
   wc.style         = CS_HREDRAW | CS_VREDRAW;
   wc.lpfnWndProc   = (WNDPROC)WndProc;      
   wc.cbClsExtra    = 0;                     
   wc.cbWndExtra    = 0;                     
   wc.hInstance     = hInstance;             
   wc.hIcon         = LoadIcon( hInstance, lpszAppName );
   wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
   wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
   wc.lpszMenuName  = lpszAppName;             
   wc.lpszClassName = lpszAppName;             

   if ( IS_WIN95 )
   {
      if ( !RegisterWin95( &wc ) )
         return( FALSE );
   }
   else if ( !RegisterClass( &wc ) )
      return( FALSE );

   hInst = hInstance;

   // Create the main application window.
   //....................................
   hWnd = CreateWindow( lpszAppName,
                        lpszTitle,   
                        WS_OVERLAPPEDWINDOW,
                        CW_USEDEFAULT, 0,
                        CW_USEDEFAULT, 0, 
                        NULL,             
                        NULL,             
                        hInstance,        
                        NULL              
                      );

   if ( !hWnd )
      return( FALSE );

   ShowWindow( hWnd, nCmdShow );
   UpdateWindow( hWnd );        

   while( GetMessage( &msg, NULL, 0, 0) )  
   {
      TranslateMessage( &msg );
      DispatchMessage( &msg ); 
   }

   return( msg.wParam );
}


BOOL RegisterWin95( CONST WNDCLASS* lpwc )
{
   WNDCLASSEX wcex;

   wcex.style         = lpwc->style;
   wcex.lpfnWndProc   = lpwc->lpfnWndProc;
   wcex.cbClsExtra    = lpwc->cbClsExtra;
   wcex.cbWndExtra    = lpwc->cbWndExtra;
   wcex.hInstance     = lpwc->hInstance;
   wcex.hIcon         = lpwc->hIcon;
   wcex.hCursor       = lpwc->hCursor;
   wcex.hbrBackground = lpwc->hbrBackground;
   wcex.lpszMenuName  = lpwc->lpszMenuName;
   wcex.lpszClassName = lpwc->lpszClassName;

   // Added elements for Windows 95.
   //...............................
   wcex.cbSize = sizeof(WNDCLASSEX);
   wcex.hIconSm = LoadImage(wcex.hInstance, lpwc->lpszClassName,
                            IMAGE_ICON, 16, 16,
                            LR_DEFAULTCOLOR );
   
   return RegisterClassEx( &wcex );
}

LRESULT CALLBACK WndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
   switch( uMsg )
   {
      case WM_COMMAND :
              switch( LOWORD( wParam ) )
              {
                 case IDM_TEST :
                        {
                           HRSRC hres = FindResource( hInst, "TestData",
                                                             RT_RCDATA );

                           if ( hres )
                           {
                              char szMsg[50];
                              DWORD    size = SizeofResource( hInst, hres );
                              HGLOBAL  hmem = LoadResource( hInst, hres );
                              RESDATA* pmem = (RESDATA*)LockResource( hmem );

                              wsprintf( szMsg, "Values loaded: %d, %d, %d/nSize = %d",
                                               pmem->Value1,
                                               pmem->Value2,
                                               pmem->Value3,
                                               size );

                              MessageBox( hWnd, szMsg, lpszAppName, MB_OK );
                           }
                        }
                        break;

                 case IDM_ABOUT :
                        DialogBox( hInst, "AboutBox", hWnd, (DLGPROC)About );
                        break;

                 case IDM_EXIT :
                        DestroyWindow( hWnd );
                        break;
              }
              break;
     
      case WM_DESTROY :
              PostQuitMessage(0);
              break;

      default :
            return( DefWindowProc( hWnd, uMsg, wParam, lParam ) );
   }

   return( 0L );
}


LRESULT CALLBACK About( HWND hDlg,          
                        UINT message,       
                        WPARAM wParam,      
                        LPARAM lParam)
{
   switch (message)
   {
       case WM_INITDIALOG:
               return (TRUE);

       case WM_COMMAND:                             
               if (   LOWORD(wParam) == IDOK        
                   || LOWORD(wParam) == IDCANCEL)   
               {
                       EndDialog(hDlg, TRUE);       
                       return (TRUE);
               }
               break;
   }

   return (FALSE);
}

#include <iostream> #include <string> using namespace std; string removeCharsMaxLex(string s) { int remove_o = 2, remove_p = 2; int remain_o = 0, remain_p = 0; // 统计剩余可删除的字符数量 for (char c : s) { if (c == 'o') remain_o++; else if (c == 'p') remain_p++; } string res; for (int i = 0; i < s.size(); ++i) { char c = s[i]; // 处理可删除字符 while (!res.empty() && ( (c > res.back() && ((res.back() == 'o' && remove_o > 0) || (res.back() == 'p' && remove_p > 0))) || (res.back() == 'o' && remain_o > remove_o) || (res.back() == 'p' && remain_p > remove_p))) { if (res.back() == 'o' && remove_o > 0) { remove_o--; res.pop_back(); } else if (res.back() == 'p' && remove_p > 0) { remove_p--; res.pop_back(); } else { break; } } // 添加当前字符 if (c == 'o') { if (remove_o > 0 && remain_o > remove_o) { res.push_back(c); remain_o--; } else if (remove_o == 0) { res.push_back(c); } else { remain_o--; remove_o--; } } else if (c == 'p') { if (remove_p > 0 && remain_p > remove_p) { res.push_back(c); remain_p--; } else if (remove_p == 0) { res.push_back(c); } else { remain_p--; remove_p--; } } else { res.push_back(c); } } // 处理末尾剩余可删除字符 while (remove_o > 0 || remove_p > 0) { if (!res.empty() && res.back() == 'o' && remove_o > 0) { res.pop_back(); remove_o--; } else if (!res.empty() && res.back() == 'p' && remove_p > 0) { res.pop_back(); remove_p--; } else { break; } } return res; } int main() { string test = "opopoop"; cout << removeCharsMaxLex(test); // 输出最大字典序结果 return 0; }改写成直接删除前两个p和后两个o
最新发布
03-16
<think>嗯,用户给了一个C++的代码,要求将其改写成直接删除前两个p和后两个o。原来的函数是removeCharsMaxLex,看起来是通过某种贪心算法来删除最多两个o和两个p,使得剩下的字符串字典序最大。现在用户希望更直接的方法,也就是直接删除前两个p和后两个o。 首先,我需要理解原代码的逻辑。原代码中使用了一些条件判断,维护了remove_o和remove_p的计数器,可能是为了在构建结果字符串时,尽可能删除某些字符以保持字典序最大。但现在用户希望直接删除前两个出现的p和后两个出现的o,所以需要改变策略。 首先,要明确需求:删除前两个p和后两个o。但要注意,这里的“前两个p”指的是字符串中顺序上最先出现的两个p,而“后两个o”则是最后出现的两个o。或者,可能用户的意思是删除前两个p和最后两个o?或者是否顺序无关?需要确认清楚。不过根据用户描述,“直接删除前两个p和后两个o”,可能是指前两个出现的p和后两个出现的o,或者可能是指前两个p和最后两个o。比如,对于字符串中的p,找到前两个出现的p并删除;对于o,找到最后两个出现的o并删除。或者,可能是删除前两个p和前两个o?不过原题中的原函数是允许最多删除两个o和两个p,所以用户可能希望直接按位置删除,而不是根据字典序的策略。 现在需要重新实现这个逻辑。原来的代码可能比较复杂,因为要维护字典序最大,而用户现在希望更直接的删除方式。那如何实现直接删除前两个p和后两个o呢? 首先,处理删除前两个p:遍历字符串,当遇到p的时候,记录次数,跳过前两次出现的p,其他的字符保留。例如,对于每个字符,如果是p且计数器小于2,就跳过,否则保留。这样就能删除前两个p。 然后,处理删除最后两个o:这需要先统计所有o的数量,或者找到最后两个o的位置。例如,遍历字符串,记录每个o的位置,然后确定最后两个o的位置,然后在第二次遍历时跳过这两个位置的o。或者,可以分两步处理:先删除前两个p,然后在处理后的字符串中删除最后两个o。 或者,先处理删除前两个p,得到中间结果,然后再处理删除最后两个o。例如: 步骤一:遍历原始字符串,删除前两个p。 步骤二:在步骤一处理后的字符串中,删除最后两个o。 这样实现的话,可能需要两次遍历,第一次处理p,第二次处理o。或者也可以在一次遍历中完成,但可能比较复杂。 具体实现方法: 对于删除前两个p,可以用一个计数器count_p,初始化为2。遍历每个字符,如果当前字符是p且count_p>0,就跳过,且count_p减一;否则,将该字符加入中间结果字符串。 然后,对中间结果字符串,处理删除最后两个o。这里需要删除最后出现的两个o。例如,从后往前遍历,找到两个o的位置,然后删除它们。或者,可以统计所有o的位置,然后删除最后两个。 例如,先收集所有o的索引,然后如果o的数量大于等于2,则删除最后两个;否则删除所有o。 具体步骤: 1. 处理前两个p: 初始化count_p = 2; 创建中间字符串s1; 遍历原字符串s的每个字符: 如果字符是p且count_p >0,则count_p--,跳过; 否则,将字符加入s1。 2. 处理后两个o: 现在处理s1字符串,删除最后两个o。例如,找到最后两个o的位置,并将它们删除。 如何找到最后两个o的位置? 可以遍历s1,记录所有o的索引到一个列表中。例如,o_indices。 如果o的数量<=2,则删除所有o; 否则,保留前o_count -2个o,删除最后两个。 或者,另一种方法:从后往前遍历,找到两个o,记录它们的索引,然后构造新字符串,排除这两个索引的字符。 例如: 构建一个列表保存要删除的o的索引。初始时,需要删除最后两个o。所以,从后到前遍历,找到两个o的位置,记录它们的索引,然后遍历字符串时跳过这些索引。 具体步骤: 创建要删除的索引集合delete_o_indices; 遍历s1的逆序,找到两个o的位置: int o_count = 0; for (int i = s1.length() -1; i >=0; i--) { if (s1[i] == 'o') { delete_o_indices.insert(i); o_count++; if (o_count ==2) break; } } 然后,遍历s1,将不在delete_o_indices中的字符加入结果字符串。 这样,就能删除最后两个出现的o。 综上,整个流程是: 原字符串 -> 删除前两个p得到s1 -> 删除最后两个o得到结果。 现在将这个逻辑用代码实现。 然后,需要修改原来的removeCharsMaxLex函数,改为上述逻辑。 原函数的参数是字符串s,返回处理后的字符串。 所以,改写后的函数可能如下: string removeCharsDirect(string s) { // 第一步:删除前两个p int count_p =2; string s1; for (char c : s) { if (c == 'p' && count_p >0) { count_p--; continue; } s1.push_back(c); } // 第二步:删除最后两个o vector<int> o_indices; for (int i = s1.size()-1; i >=0; i--) { if (s1[i] == 'o') { o_indices.push_back(i); if (o_indices.size() ==2) break; } } string res; for (int i=0; i < s1.size(); i++) { if (find(o_indices.begin(), o_indices.end(), i) != o_indices.end()) { continue; } res.push_back(s1[i]); } return res; } 这样,这个函数先处理前两个p,然后处理最后两个o。例如,原测试用例是"opopoop"。 原字符串是 o p o p o o p。原函数的输出需要看原代码的输出。但用户给出的测试用例的输出由原函数给出,现在改写后的函数应该如何处理? 让我们手动测试一下: 原字符串是 "opopoop"。 第一步,删除前两个p: 遍历每个字符,前两个p会被删除: 原字符串:索引0: o,保留;索引1: p(count_p=2>0,删除,count_p=1);索引2: o,保留;索引3: p(count_p=1>0,删除,count_p=0);索引4: o,保留;索引5: o,保留;索引6: p,此时count_p=0,所以保留。 所以,s1是 o, o, o, o, p →字符串是 "oooop"? 或者原字符串是 "opopoop",即每个字符依次是 o p o p o o p。总共有3个p。删除前两个p: 第一个字符是 o →加入s1. 第二个字符是 p →count_p=2,删除,count_p=1. 第三个字符是 o →加入. 第四个字符是 p →count_p=1,删除,count_p=0. 第五个字符是 o →加入. 第六个字符是 o →加入. 第七个字符是 p →此时count_p=0,加入. 所以,s1是 o, o, o, o, p →字符串是 "oooo p" →合并为 "oooop"? 现在s1是 "oooop"。现在处理删除最后两个o。在这个字符串中,所有的字符是 o o o o p。所以,四个o和一个p。 最后两个o的索引是3和2(假设索引从0开始): 字符串索引0: o 1: o 2: o 3: o 4: p 所以,从后往前找o,找到索引3和2。删除这两个索引的字符,剩下的字符是索引0、1、4,即 o o p。所以最终结果是 "oop"。 而原代码的输出呢?原代码的输出是当输入是"opopoop"时,输出最大字典序的结果。原代码的逻辑是尽可能删除某些o和p,使得剩下的字符串字典序最大。例如,原问题中的函数可能返回的是"ppoo",或者类似的结果。但根据用户提供的测试用例,原代码的输出可能需要进一步分析。但用户希望改写后的代码输出是删除前两个p和后两个o的结果,所以对于输入"opopoop",输出应为"oop"。 那么,主函数中的测试代码应该输出"oop"? 或者,原测试用例的输出是原代码的输出,而改写后的代码的输出可能不同。用户可能希望改写后的代码直接删除前两个p和后两个o,所以原测试用例的输出可能由原来的逻辑(比如"ppoo")变成现在的"oop"。 综上,代码改写后的逻辑是: 删除前两个出现的p,然后删除最后两个出现的o。这样,最终的结果字符串就是处理后的结果。 现在,编写对应的C++代码,并测试是否正确。 现在,针对原代码中的测试用例: 输入是"opopoop",原代码的输出是?原函数可能返回一个最大字典序的结果,比如,假设原字符串处理后的结果是尽可能让较大的字符留在前面。但改写后的代码直接删除前两个p和后两个o,得到的结果可能不同。 现在,原题中的示例输入是"opopoop",原代码的输出是cout << removeCharsMaxLex(test); 用户希望改写后的代码直接删除前两个p和后两个o,那么正确的输出应该是什么? 例如,原字符串是 "o p o p o o p",删除前两个p(索引1和3),得到中间字符串 "o o o o p"。然后删除最后两个o(索引3和2),剩下的是索引0、1、4的字符,即 o o p → "oop"。 所以,改写后的代码应该输出"oop"。 现在,将代码改写为上述的removeCharsDirect函数,并在main中测试,输出结果是否是"oop"。 那现在的代码是否正确? 现在,再检查一遍代码: 在删除前两个p时,正确遍历每个字符,当遇到p且count_p>0时跳过。 在第二步,删除最后两个o时,从后往前找到最后两个o的索引,存入o_indices,然后构造结果时跳过这些索引。 例如,对于中间字符串s1是"oooop",索引0到4是o o o o p。遍历从后到前,找到两个o,索引3和2。所以,构造结果时,排除这两个索引,剩下的字符是0,1,4 → o o p → "oop"。 是的,这样是正确的。 那现在,将原代码中的removeCharsMaxLex替换为removeCharsDirect,主函数中的输出应该为"oop"。 所以,用户提供的代码需要改写,将原来的复杂逻辑改为直接删除前两个p和后两个o的逻辑。 总结步骤: 1. 遍历字符串,删除前两个p。 2. 在结果字符串中,删除最后两个o。 这样就能达到目标。</think>以下是将代码改写为直接删除前两个 `p` 和后两个 `o` 的分步解释和代码实现: --- ### 改写思路 原代码通过贪心策略维护字典序最大,而改写后的目标更直接: 1. **删除前两个 `p`**:按顺序遍历字符串,跳过前两次出现的 `p`。 2. **删除最后两个 `o`**:在第一步的结果中,从后往前找到最后两个 `o` 并删除。 --- ### 分步实现 #### 步骤 1:删除前两个 `p` - 遍历字符串,用计数器记录已删除的 `p` 数量,跳过前两次出现的 `p`。 #### 步骤 2:删除最后两个 `o` - 从第一步的结果字符串中,逆向查找最后两个 `o` 的索引,构造新字符串时跳过它们。 --- ### 代码实现 ```cpp #include <iostream> #include <string> #include <vector> #include <algorithm> // 用于 find 函数 using namespace std; string removeCharsDirect(string s) { // 第一步:删除前两个 'p' int delete_p = 2; string temp; for (char c : s) { if (c == 'p' && delete_p > 0) { delete_p--; continue; // 跳过当前 'p' } temp.push_back(c); } // 第二步:删除最后两个 'o' vector<int> o_indices; // 存储要删除的 'o' 的索引 for (int i = temp.size() - 1; i >= 0 && o_indices.size() < 2; --i) { if (temp[i] == 'o') { o_indices.push_back(i); } } string result; for (int i = 0; i < temp.size(); ++i) { // 如果当前索引不在待删除列表中,则保留字符 if (find(o_indices.begin(), o_indices.end(), i) == o_indices.end()) { result.push_back(temp[i]); } } return result; } int main() { string test = "opopoop"; cout << removeCharsDirect(test); // 输出 "oop" return 0; } ``` --- ### 关键代码解释 1. **删除前两个 `p`**: - 使用计数器 `delete_p` 跟踪剩余需删除的 `p` 数量。 - 当遇到 `p` 且仍需删除时,跳过该字符。 2. **删除最后两个 `o`**: - 逆向遍历字符串,记录最后两个 `o` 的索引。 - 正向遍历时,跳过这些索引对应的字符。 --- ### 示例输入输出 - **输入字符串**:`"opopoop"`(即 `o p o p o o p`) - **处理过程**: 1. 删除前两个 `p` → 得到 `o o o o p` 2. 删除最后两个 `o`(索引 3 和 2)→ 得到 `o o p` - **最终输出**:`"oop"` 此方法直接按顺序和逆序操作字符,确保逻辑简单清晰。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值