코딩도사의 코드정리

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <limits>
#include <ctime>
#include <set>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
using namespace std;

#ifdef mycom
ifstream fin("input");
#else
#define fin cin
#endif

class team
{
public:
 int score;
 int wincounter;
 int goaldiff;
 int manygoal;
 int gamecounter;
 string teamname;

 ////////////
 int drawcounter;
 int losecounter;
 int sibalgoal;
 team() { 
  score = 0;
  wincounter = 0;
  goaldiff = 0;
  manygoal = 0;
  gamecounter = 0;
  drawcounter=0;
  losecounter=0;
  sibalgoal=0;
 }
 
 bool operator<(const team& t) const
 {
  if(this->score == t.score)
  {
   if(this->wincounter == t.wincounter)
   {
    if(this->goaldiff == t.goaldiff)
    {
     if(this->manygoal == t.manygoal)
     {
      if(this->gamecounter == t.gamecounter)
      {
       char ateam[100];
       char bteam[100];
       strcpy(ateam, teamname.c_str());
       strcpy(bteam, t.teamname.c_str());
       for(int i=0; i<strlen(ateam); i++)
        ateam[i] = toupper(ateam[i]);
       for(int i=0; i<strlen(bteam); i++)
        bteam[i] = toupper(bteam[i]);
       string a = ateam;
       string b = bteam;
       return a > b;
      }
      else
      {
       return this->gamecounter > t.gamecounter;
      }
     }
     else
     {
      return this->manygoal < t.manygoal;
     }
    }
    else
    {
     return this->goaldiff < t.goaldiff;
    }
   }
   else
   {
    return this->wincounter < t.wincounter;
   }
  }
  else
  {
   return this->score < t.score;
  }
 }
};


int main()
{
 int N;
 
 fin >> N;
 fin.ignore(1024, '\n');
 for(int n=1; n<=N; n++)
 {
  int T;
  
  string tonorname;
  char temptonorname[1024];
  
  fin.getline(temptonorname, 1024);
  tonorname = temptonorname;
  fin >> T;
  fin.ignore(1024, '\n');
  vector<team> teams;
  for(int j=1; j<=T; j++)
  {
   char temp[1024];
   fin.getline(temp, 1024);
   team tempteam;
   tempteam.teamname = temp;
   teams.push_back(tempteam);
  }

  int G;
  fin >> G;
  fin.ignore(1024, '\n');
  for(int g=1; g<=G; g++)
  {
   char temp[1024];
   char* p;
   
   int Ascore, Bscore;
   string Aname;
   string Bname;
   fin.getline(temp, 1024);
   p = strtok(temp, "#");
   Aname = p;
   p = strtok(0, "@");
   Ascore = atoi(p);
   p = strtok(0, "#");
   Bscore = atoi(p);
   p = strtok(0, "#");
   Bname = p;
   for(vector<team>::iterator iter = teams.begin(); iter != teams.end(); ++iter)
   {
    if((*iter).teamname == Aname)
    {
     if(Ascore > Bscore)
     {
      iter->score += 3;
      iter->wincounter++;
     }
     else if(Ascore == Bscore)
     {
      iter->drawcounter++;
      iter->score += 1;
     }
     else
      iter->losecounter++;
     iter->sibalgoal += Bscore;
     iter->manygoal += Ascore;
     iter->gamecounter++;
     iter->goaldiff += Ascore - Bscore;
    }
    else if( (*iter).teamname == Bname)
    {
     if(Bscore > Ascore)
     {
      iter->score += 3;
      iter->wincounter++;
     }
     else if(Ascore == Bscore)
     {
      iter->score += 1;
      iter->drawcounter++;
     }
     else
      iter->losecounter++;
     iter->sibalgoal += Ascore;
     iter->manygoal += Bscore;
     iter->gamecounter++;
     iter->goaldiff += Bscore - Ascore;
    }
   }

  }
  sort(teams.rbegin(), teams.rend());
  cout << tonorname << endl;
  for(int i = 0; i<teams.size(); i++)
  {
   printf("%d) %s %dp, %dg (%d-%d-%d), %dgd (%d-%d)\n", 
    i+1,
    teams[i].teamname.c_str(),
    teams[i].score,
    teams[i].gamecounter, 
    teams[i].wincounter,
    teams[i].drawcounter,
    teams[i].losecounter,
    teams[i].goaldiff,
    teams[i].manygoal,
    teams[i].sibalgoal);
  }
  if(n != N)
   cout << endl;
 }
 return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <limits>
#include <time.h>
#include <set>
using namespace std;


#ifdef mycom
#include <fstream>
ifstream fin("input");
#else
#define fin cin
#endif

vector<int> A;
vector<int> B;

 

 


int main()
{
 int testcase;

 testcase = 1;
 fin >> testcase;

 int hours;
 string solution; 
 solution.resize(10000);
 for(int i=1; i<=testcase; i++)
 {
  solution = "";

  hours = 0;
  int n;
  fin >> n;

  for(int j=1; j<=n; j++)
  {
   int temp;
   fin >> temp;
   A.push_back(temp);
  }

  sort(A.begin(), A.end());
  //saram 에 대한 처리가 들어감
  while(A.empty() == false)
  {
   if(A.size() == 1)
   {
    vector<int>::iterator b = A.begin();
    int _A = *b;

    B.insert(B.begin(), A.begin(), A.end());
    A.clear();

    char buf[256];
    sprintf(buf, "%d\n", _A);
    solution += buf;
    hours += _A;
   }
   else if(A.size() == 2)
   {
    vector<int>::iterator b = A.begin();
    int _A = *b;
    b++;
    int _B = *b;

    B.insert(B.begin(), A.begin(), A.end());
    A.clear();
    char buf[256];
    sprintf(buf, "%d %d\n", _A, _B);
    solution += buf;
    hours += _B;
   }
   else if(A.size() == 3)
   {
    vector<int>::iterator b = A.begin();
    int _A = *b;
    b++;
    int _B = *b;
    b++;
    int _C = *b;


    B.insert(B.begin(), A.begin(), A.end());
    A.clear();
    char buf[256];

    sprintf(buf, "%d %d\n", _A, _B);
    solution += buf;

    sprintf(buf, "%d\n", _A);
    solution += buf;

    sprintf(buf, "%d %d\n", _A, _C);
    solution += buf;
    hours += _A + _B + _C;
   }
   else if(A.size() >= 4)
   {
    vector<int>::iterator b = A.begin();
    vector<int>::reverse_iterator rb = A.rbegin();
    int _A = *b;
    b++;
    int _B = *b;
    int _Z = *rb;
    rb++;
    int _Y = *rb;

    A.erase(find(A.begin(), A.end(), _Y));
    A.erase(find(A.begin(), A.end(), _Z));
    //A.erase(_Y);
    //A.erase(_Z);
    B.push_back(_Y);
    B.push_back(_Z);
    if(_A + 2*_B + _Z <= 2*_A + _Y + _Z)
    {    
     char buf[256];
     sprintf(buf, "%d %d\n", _A, _B);
     solution += buf;
     sprintf(buf, "%d\n", _A);
     solution += buf;
     sprintf(buf, "%d %d\n", _Y, _Z);
     solution += buf;
     sprintf(buf, "%d\n", _B);
     solution += buf;

     hours += _A + 2*_B + _Z;
    }
    else
    {
     char buf[256];
     sprintf(buf, "%d %d\n", _A, _Z);
     solution += buf;
     sprintf(buf, "%d\n", _A);
     solution += buf;
     sprintf(buf, "%d %d\n", _A, _Y);
     solution += buf;
     sprintf(buf, "%d\n", _A);
     solution += buf;
     hours += 2*_A + _Y + _Z;
    }
   }
   sort(A.begin(), A.end());
   sort(B.begin(), B.end());
  }
  cout << hours <<endl << solution;
  if(testcase  != i)
   cout << endl;
 }

 return 0;
}

 

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <limits>
#include <time.h>
#include <set>
#include <cmath>
using namespace std;
//#define mycom
#ifdef mycom
#include <fstream>
ifstream fin("input");
#else
#define fin cin
#endif

using namespace std;
int main()
{
 int casenumber;
 fin >> casenumber;

 for(int i=1; i<=casenumber; i++)
 {
  int headnumber;
  fin >> headnumber;
  vector<int> s;
  for(int j=1; j<=headnumber; j++)
  {
   int temp;
   fin >> temp;
   s.push_back(temp);
  }
  
  int nmin = numeric_limits<int>::max();
  
  for(vector<int>::iterator iter = s.begin(); iter != s.end(); ++iter)
  {
   int sum = 0;
   for(vector<int>::iterator iter2 = s.begin(); iter2 != s.end(); ++iter2)
   {
    sum += abs(*iter - *iter2);
   }
   nmin = min(sum, nmin);
  }

  cout << nmin << endl;
 }
 return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <limits>
#include <time.h>
using namespace std;
#define mycom
#ifdef mycom
#include <fstream>
ifstream fin("input");
#else
#define fin cin
#endif

struct Node
{
 string vertex;
 Node* adj;
 bool operator==(const Node& n) const
 {
  return (vertex == n.vertex);
 }
 bool operator<(const Node& n) const
 {
  return vertex < n.vertex;
 }
};


vector<Node> graph;


void CreateVertex(const string& v)
{
 Node n;
 n.vertex = v;
 n.adj = 0;
 bool bfind = false;
 if( find(graph.begin(), graph.end(), n) == graph.end() ) // 없
  graph.push_back(n);
}


void link(const string& from, const string& to)
{
 Node s;
 s.vertex = from;
 vector<Node>::iterator fromiter = find(graph.begin(), graph.end(), s);
 Node* p = new Node;
 p->vertex = to;
 p->adj = fromiter->adj;
 fromiter->adj = p;
}


int sina;
int non;
int saram;

 


int mymin = 9999999;
map<string, bool> visit;
void dfs(const string& curnode, int mycount)
{
 //해가 맞는가?
 //아니면
 //모든 경우에 대해 백트
 visit[curnode] = true;
 ///cout << curnode << endl;
 if(curnode == "Erdos, P.")
 {
  if (mycount < mymin)
   mymin = mycount;
 } else
 {
  Node s;
  s.vertex = curnode;
  Node* p = &(*find(graph.begin(), graph.end(), s));
  while(p)
  {   
   if(mymin > mycount )
   {
    if( p->adj && !visit[p->adj->vertex] )
     dfs(p->adj->vertex, mycount + 1);
   }
   p = p->adj;
  }
 }
 visit[curnode] = false;
}


int main()
{

 
 fin >> sina;
 for (int i = 1; i <= sina; i++)
 {
  //memset(graph, 0, sizeof(graph));


  fin >> non >> saram;
  //
  char t;
  while (fin.get(t) && t != '\n')
   ;
  
  for (int j = 1; j <= non; j++)
  {


   char temp[1024];
   fin.getline(temp, 1024);
   int startpos = 0;
   vector<string> v;
   for (int i = 0; i < strlen(temp); i++)
   { // 문자열 파싱.
    if (strncmp(&temp[i], ".,", 2) == 0 || strncmp(&temp[i], ".:", 2) == 0)
    {
     string strtemp;
     strtemp.assign(&temp[startpos], &temp[i + 1]);
     v.push_back(strtemp);


     startpos = i + 3;
    }
   }

   
   //이어주기
   for (int z = 0; z < v.size(); z++)
   {
    for (int z2 = 0; z2 < v.size(); z2++)
    {
     if(z != z2)
     {
      CreateVertex(v[z]);
      CreateVertex(v[z2]);
      link(v[z], v[z2]);
      //link(v[z2], v[z]);
     }
    }
   }
   
  }
  
  //for(map<string, int>::iterator i = dic.begin(); i != dic.end(); i++)
  // cout << i->first << i->second << endl;
  //while (fin.get(t) && t != '\n');
  cout << "Scenario " << i << endl;
  
  char temp[1024];
  for (int j = 1; j <= saram; j++)
  {
   fin.getline(temp, 1024);
   
   mymin = numeric_limits<int>::max();
   clock_t start = clock(); 
   dfs(temp, 0);
   //cout << clock() - start << endl;
   if (mymin == numeric_limits<int>::max())
    cout << temp << " " << "infinity" << endl;
   else
    cout << temp << " " << mymin << endl;
  }
 }


 return 0;
}

매크로를 쓰면 된다(ALT+F11)

Public Module SwitchCHPP
    Sub OpenPartnerFile()
        Dim filename As String
        Dim partnerFilename As String
        filename = DTE.ActiveDocument.FullName
        If (filename.EndsWith(".h")) Then
            partnerFilename = filename.Substring(0, filename.Length() - 2) + ".cpp"
        End If
        If (filename.EndsWith(".cpp")) Then
            partnerFilename = filename.Substring(0, filename.Length() - 4) + ".h"
        End If
        DTE.ItemOperations.OpenFile(partnerFilename)
    End Sub
End Module

abcdaXbcdabcdX 와 같은 문자가 있으면
(a.+X).* 로 매치했을 때 abcdaXbcdabcdX 가 매치되지만
아래와 같은
(a.+?X).* 같은 표현으로 매치하면 abcdaX 가 매치된다.
*?
+?

{n,}?

이까지는 이해가 가는데

?? 라는 표현도 있음.

예를 들어 표현하면

a??c 를 했을 때

abc444ac 라는게 있다면 abc 를 찾는게 아니고 ac 를 찾음

가능한한 짧은걸 찾음.

Back references

std::string s("apple banana");
 std::tr1::regex rg("(.+) (.+)");
 s = std::tr1::regex_replace(s,rg,std::string("$2 $1"));
 cout << s << endl;

결과값 : banana apple
매치하면서 썼던 문자집합을 $n 와 같은 표현으로 사용가능.

#include <iostream>
#include <windows.h>

// DLL Inject : 다른 프로세스의 주소 공간에 특정 DLL을 넣는다.
void DllInject(DWORD pid, char* path)
{
        HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, 0, pid);

        // 내 프로세스에 있는 KERNEL32.DLL의 주소와 LoadLibrary의 주소를 구한다.
        HMODULE hDll = GetModuleHandle("kernel32.dll"); // kernel32.dll 모듈의 핸들값을 GetModuleHandle로 구한다.
        PTHREAD_START_ROUTINE f = (PTHREAD_START_ROUTINE)GetProcAddress(hDll, "LoadLibraryA");


        // 계산기의 주소공간에 메모리를 할당하고, DLL의 경로를 복사해준다.
        // VirtualAlloc은 가상 메모리를 할당하는 API이지만, Ex가 붙으면 다른 프로세스의 주소공간을 할당할 수 있다.
        void* p = VirtualAllocEx(hProcess, 0, // 원하는 주소(0은 알아서 해달라)
                strlen(path)+1, // 크기
                MEM_RESERVE | MEM_COMMIT, // 예약과 동시 확정
                PAGE_READWRITE);

        // 이제 DLL의 경로를 담을 문자열 복사
        // WriteProcessMemory()는 다른 프로세스 주소 공간에 무언가를 쓸 수 있다.
        DWORD len;
        WriteProcessMemory(hProcess, p, path, strlen(path)+1, &amp;len);

        // 계산기에 새로운 스레드를 만든다.
        // CreateRemoteThread는 다른 프로세스에 스레드를 생성시킨다.
        HANDLE hThread = CreateRemoteThread(hProcess, // 계산기 핸들
                0, 0, 
                f, p, // 함수, 파리미터
                0, 0);


        CloseHandle(hThread);
        CloseHandle(hProcess);
}

void main()
{
        using namespace std;
        HWND hwnd = (HWND)0x0005115A;
        DWORD pid;
        DWORD tid = GetWindowThreadProcessId(hwnd, &amp;pid);
        DllInject(pid, "C:\\spy1.dll");
}

#include <urlmon.h>
#include <iostream>
#include <commctrl.h>
#include<windows.h>
#include<dbghelp.h>
#include<stdio.h>
#pragma comment(lib,"dbghelp.lib")



// Repalce 부분..

void Replace( char *dll_name,                          // dll 이름

                                         PROC proc,             // hooking 할 함수

                                         PROC new_proc,     // 새로운 함수

                                         HMODULE hMod)     // .idata 섹션을 조사할 모듈 핸들

                                                                         // (exe 주소)

{

             // hMod 주소에서 .idata의 위치를 찾는다.

             ULONG sz;

             PIMAGE_IMPORT_DESCRIPTOR pImport = (PIMAGE_IMPORT_DESCRIPTOR)

                        ImageDirectoryEntryToDatahMod, 

                        TRUE,IMAGE_DIRECTORY_ENTRY_IMPORT,       // IMPORT하고 있는 곳

                         &amp;sz);



             if(pImport==0)                // .idata section이 없는 경우.

                          return;



             //===================================================

             // .idata에서 원하는 dll의 위치를 찾는다.

             for(;pImport-&gt;Name;++pImport)

             {

                          char* p = (char*)hMod+pImport-&gt;Name;



                          if(strcmpi(p,dll_name)==0)                   // 찾은 경우

                                       break;

             }

             if(pImport-&gt;Name==0)             return; // .idata항목에 해당하는 DLL이 없다.

             //====================================================

             // thunktable에서 원하는 함수를 찾아서 바꾸어 쓴다.

             PIMAGE_THUNK_DATA pThunk=(PIMAGE_THUNK_DATA)

             ((char*)hMod+pImport-&gt;FirstThunk);



             

             for(;pThunk-&gt;u1.Function;++pThunk)

             {

                          PROC* pf=(PROC*)&amp;(pThunk-&gt;u1.Function);



                          if(*pf==proc)                // 찾은 경우.

                          {

                                       *pf=new_proc;              // 덮어쓴다.

                          }

             }

}



// MessageBoxW를 대신할 함수

UINT WINAPI foo(HWND hwnd,PCWSTR s,PCWSTR title,UINT btn)

{

             // Console 참을 생성해서 출력해준다.



             AllocConsole();



             freopen("CONOUT$","wt",stdout);



             printf("Messagebox 호출");



             return 0;

}



BOOL WINAPI DllMain(HANDLE h,DWORD r,void*p)

{

             if(r==DLL_PROCESS_ATTACH)

             {

                          Replace("User32.dll",

                                       (PROC)MessageBoxA,

                                       (PROC)foo,

                                       GetModuleHandle(0));

             }

             return TRUE;

}