PHIL'S BLUE SKY

假设知道 RGB的信息lpImage, 宽高分别为iWidth ,iHeight
[code]
int size = iWidth * iHeight * 3;
 BITMAPFILEHEADER bfh;
 BITMAPINFOHEADER bih;
 bfh.bfType = 0x4d42;
 bfh.bfSize = size + sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
 bfh.bfReserved1 = 0; bfh.bfReserved2 = 0;
 bfh.bfOffBits = bfh.bfSize - size;

 
 bih.biSize = sizeof(BITMAPINFOHEADER);
 bih.biWidth = iWidth;
 bih.biHeight = iHeight;
 bih.biPlanes = 1;
 bih.biBitCount = 24;
 bih.biCompression = 0;
 bih.biSizeImage = size;
 bih.biXPelsPerMeter = 0;
 bih.biYPelsPerMeter = 0;
 bih.biClrUsed = 0;
 bih.biClrImportant = 0;
 fp = fopen (buf, "wb");
 fwrite (&bfh, 1, sizeof (BITMAPFILEHEADER), fp);
 fwrite (&bih, 1, sizeof (BITMAPINFOHEADER), fp);
 fwrite (lpImage, 1, size, fp);
 fclose(fp);
[/code]

/***
*qsort.c - quicksort algorithm; qsort() library function for sorting arrays
*
*       Copyright (c) Microsoft Corporation. All rights reserved.
*
*Purpose:
*       To implement the qsort() routine for sorting arrays.
*
*******************************************************************************/

#include <cruntime.h>
#include <stdlib.h>
#include <search.h>
#include <internal.h>

/* Always compile this module for speed, not size */
#pragma optimize("t", on)

/* prototypes for local routines */
static void __cdecl shortsort(char *lo, char *hi, size_t width,
                int (__cdecl *comp)(const void *, const void *));
static void __cdecl swap(char *p, char *q, size_t width);

/* this parameter defines the cutoff between using quick sort and
   insertion sort for arrays; arrays with lengths shorter or equal to the
   below value use insertion sort */

#define CUTOFF 8            /* testing shows that this is good value */

/***
*qsort(base, num, wid, comp) - quicksort function for sorting arrays
*
*Purpose:
*       quicksort the array of elements
*       side effects:  sorts in place
*       maximum array size is number of elements times size of elements,
*       but is limited by the virtual address space of the processor
*
*Entry:
*       char *base = pointer to base of array
*       size_t num  = number of elements in the array
*       size_t width = width in bytes of each array element
*       int (*comp)() = pointer to function returning analog of strcmp for
*               strings, but supplied by user for comparing the array elements.
*               it accepts 2 pointers to elements and returns neg if 1<2, 0 if
*               1=2, pos if 1>2.
*
*Exit:
*       returns void
*
*Exceptions:
*
*******************************************************************************/

/* sort the array between lo and hi (inclusive) */

#define STKSIZ (8*sizeof(void*) - 2)

void __cdecl qsort (
    void *base,
    size_t num,
    size_t width,
    int (__cdecl *comp)(const void *, const void *)
    )
{
    /* Note: the number of stack entries required is no more than
       1 + log2(num), so 30 is sufficient for any array */
    char *lo, *hi;              /* ends of sub-array currently sorting */
    char *mid;                  /* points to middle of subarray */
    char *loguy, *higuy;        /* traveling pointers for partition step */
    size_t size;                /* size of the sub-array */
    char *lostk[STKSIZ], *histk[STKSIZ];
    int stkptr;                 /* stack for saving sub-array to be processed */

    if (num < 2 || width == 0)
        return;                 /* nothing to do */

    stkptr = 0;                 /* initialize stack */

    lo = base;
    hi = (char *)base + width * (num-1);        /* initialize limits */

    /* this entry point is for pseudo-recursion calling: setting
       lo and hi and jumping to here is like recursion, but stkptr is
       preserved, locals aren't, so we preserve stuff on the stack */
recurse:

    size = (hi - lo) / width + 1;        /* number of el's to sort */

    /* below a certain size, it is faster to use a O(n^2) sorting method */
    if (size <= CUTOFF) {
        shortsort(lo, hi, width, comp);
    }
    else {
        /* First we pick a partitioning element.  The efficiency of the
           algorithm demands that we find one that is approximately the median
           of the values, but also that we select one fast.  We choose the
           median of the first, middle, and last elements, to avoid bad
           performance in the face of already sorted data, or data that is made
           up of multiple sorted runs appended together.  Testing shows that a
           median-of-three algorithm provides better performance than simply
           picking the middle element for the latter case. */

        mid = lo + (size / 2) * width;      /* find middle element */

        /* Sort the first, middle, last elements into order */
        if (comp(lo, mid) > 0) {
            swap(lo, mid, width);
        }
        if (comp(lo, hi) > 0) {
            swap(lo, hi, width);
        }
        if (comp(mid, hi) > 0) {
            swap(mid, hi, width);
        }

        /* We now wish to partition the array into three pieces, one consisting
           of elements <= partition element, one of elements equal to the
           partition element, and one of elements > than it.  This is done
           below; comments indicate conditions established at every step. */

        loguy = lo;
        higuy = hi;

        /* Note that higuy decreases and loguy increases on every iteration,
           so loop must terminate. */
        for (;;) {
            /* lo <= loguy < hi, lo < higuy <= hi,
               A[i] <= A[mid] for lo <= i <= loguy,
               A[i] > A[mid] for higuy <= i < hi,
               A[hi] >= A[mid] */

            /* The doubled loop is to avoid calling comp(mid,mid), since some
               existing comparison funcs don't work when passed the same
               value for both pointers. */

            if (mid > loguy) {
                do  {
                    loguy += width;
                } while (loguy < mid && comp(loguy, mid) <= 0);
            }
            if (mid <= loguy) {
                do  {
                    loguy += width;
                } while (loguy <= hi && comp(loguy, mid) <= 0);
            }

            /* lo < loguy <= hi+1, A[i] <= A[mid] for lo <= i < loguy,
               either loguy > hi or A[loguy] > A[mid] */

            do  {
                higuy -= width;
            } while (higuy > mid && comp(higuy, mid) > 0);

            /* lo <= higuy < hi, A[i] > A[mid] for higuy < i < hi,
               either higuy == lo or A[higuy] <= A[mid] */

            if (higuy < loguy)
                break;

            /* if loguy > hi or higuy == lo, then we would have exited, so
               A[loguy] > A[mid], A[higuy] <= A[mid],
               loguy <= hi, higuy > lo */

            swap(loguy, higuy, width);

            /* If the partition element was moved, follow it.  Only need
               to check for mid == higuy, since before the swap,
               A[loguy] > A[mid] implies loguy != mid. */

            if (mid == higuy)
                mid = loguy;

            /* A[loguy] <= A[mid], A[higuy] > A[mid]; so condition at top
               of loop is re-established */
        }

        /*     A[i] <= A[mid] for lo <= i < loguy,
               A[i] > A[mid] for higuy < i < hi,
               A[hi] >= A[mid]
               higuy < loguy
           implying:
               higuy == loguy-1
               or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid] */

        /* Find adjacent elements equal to the partition element.  The
           doubled loop is to avoid calling comp(mid,mid), since some
           existing comparison funcs don't work when passed the same value
           for both pointers. */

        higuy += width;
        if (mid < higuy) {
            do  {
                higuy -= width;
            } while (higuy > mid && comp(higuy, mid) == 0);
        }
        if (mid >= higuy) {
            do  {
                higuy -= width;
            } while (higuy > lo && comp(higuy, mid) == 0);
        }

        /* OK, now we have the following:
              higuy < loguy
              lo <= higuy <= hi
              A[i]  <= A[mid] for lo <= i <= higuy
              A[i]  == A[mid] for higuy < i < loguy
              A[i]  >  A[mid] for loguy <= i < hi
              A[hi] >= A[mid] */

        /* We've finished the partition, now we want to sort the subarrays
           [lo, higuy] and [loguy, hi].
           We do the smaller one first to minimize stack usage.
           We only sort arrays of length 2 or more.*/

        if ( higuy - lo >= hi - loguy ) {
            if (lo < higuy) {
                lostk[stkptr] = lo;
                histk[stkptr] = higuy;
                ++stkptr;
            }                           /* save big recursion for later */

            if (loguy < hi) {
                lo = loguy;
                goto recurse;           /* do small recursion */
            }
        }
        else {
            if (loguy < hi) {
                lostk[stkptr] = loguy;
                histk[stkptr] = hi;
                ++stkptr;               /* save big recursion for later */
            }

            if (lo < higuy) {
                hi = higuy;
                goto recurse;           /* do small recursion */
            }
        }
    }

    /* We have sorted the array, except for any pending sorts on the stack.
       Check if there are any, and do them. */

    --stkptr;
    if (stkptr >= 0) {
        lo = lostk[stkptr];
        hi = histk[stkptr];
        goto recurse;           /* pop subarray from stack */
    }
    else
        return;                 /* all subarrays done */
}

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

using namespace std;

int main()
{
 int n, f[10],digit[10], dcnt, ans[10], i, j, k;

 for(i = 0; i < 10; i++) f[i] = i * (int)pow(10, i-1);
 while(cin >> n)
 {
  assert(n > 0);
  memset(ans, 0, 10*sizeof(int));

  int t = n;
  dcnt = 0;
  while(t)
  {
   digit[dcnt++] = t % 10;
   t /= 10;
  }

  int tt = n;
  for(i = dcnt-1; i >= 0; i--)
  {
   for(j = 0; j < digit[i]; j++)
   {
    ans[j] += (int)pow(10, i);
    for(k = 0; k < 10; k++)
     ans[k] += f[i];
   }
   tt -= (int)digit[i] * pow(10, i);
   ans[ digit[i] ] += (tt + 1);
  }
  tt = n;
  for(i = 1; i <= dcnt; i++)
  {
   ans[0] -= (int)i* (pow(10, dcnt-i) - pow(10, dcnt-i-1));
  }
  for(i = 0; i < 10; i++)
   cout << "ans[" << i << "] = " << ans[i] << endl;
 }
 system("pause");
 return 0;
}

#define N 8

#include <iostream>
#include <stack>

using namespace std;

struct snode
{
 int cnt, pos;
 bool poped;
};

int main()
{

 stack<snode> sk;
 snode nod, nod1, nod2;
 bool b[N]; int subsetnum = 0;
 for(int k=1; k<=N; k++)
 {
  memset(b, false, N);
  nod.cnt=0; nod.pos=0; nod.poped = false;
  sk.push(nod);
  while(!sk.empty())
  {
   nod = sk.top();
   sk.pop();
   if(nod.cnt==k)
   {
    for(int j=0; j<nod.pos; j++)
     if(b[j]) cout << j << ",";
    cout << endl;
    subsetnum ++;
    continue;
   }
   if(nod.pos==N) continue;

   if(!nod.poped)
   {
    nod.poped = true;
    sk.push(nod);
   }
   else
   {
    nod.poped = false;
    b[nod.pos++] = false;
    sk.push(nod);
    continue;
   }

   if(nod.pos<N)
   {
    b[nod.pos++] = true;
    nod.poped = false;
    nod.cnt++;
    sk.push(nod);
   }
  }
 }
 cout << subsetnum << endl;
 return 0;
}

（一）成长的寓言：做一棵永远成长的苹果树
一棵苹果树，终于结果了。
第一年，它结了10个苹果，9个被拿走，自己得到1个。对此，苹果树愤愤不平，于是自断经脉，拒绝成长。第二年，它结了5个苹果，4个被拿走，自己得到1个。“哈哈，去年我得到了10％，今年得到20％！翻了一番。”这棵苹果树心理平衡了。但是，它还可以这样：继续成长。譬如，第二年，它结了100个果子，被拿走90个，自己得到10个。很可能，它被拿走99个，自己得到1个。但没关系，它还可以继续成长，第三年结1000个果子……
其实，得到多少果子不是最重要的。最重要的是，苹果树在成长！等苹果树长成参天大树的时候，那些曾阻碍它成长的力量都会微弱到可以忽略。真的，不要太在乎果子，成长是最重要的。

【心理点评】你是不是一个已自断经脉的打工族？
刚开始工作的时候，你才华横溢，意气风发，相信“天生我才必有用”。但现实很快敲了你几个闷棍，或许，你为单位做了大贡献没人重视；或许，只得到口头重视但却得不到实惠；或许……总之，你觉得就像那棵苹果树，结出的果子自己只享受到了很小一部分，与你的期望相差甚远。
于是，你愤怒、你懊恼、你牢骚满腹……最终，你决定不再那么努力，让自己的所做去匹配自己的所得。几年过去后，你一反省，发现现在的你，已经没有刚工作时的激情和才华了。“老了，成熟了。”我们习惯这样自嘲。但实质是，你已停止成长了。这样的故事，在我们身边比比皆是。之所以犯这种错误，是因为我们忘记生命是一个历程，是一个整体，我们觉得自己已经成长过了，现在是到该结果子的时候了。我们太过于在乎一时的得失，而忘记了成长才是最重要的。好在，这不是金庸小说里的自断经脉。我们随时可以放弃这样做，继续走向成长之路。
切记：如果你是一个打工族，遇到了不懂管理、野蛮管理或错误管理的上司或企业文化，那么，提醒自己一下，千万不要因为激愤和满腹牢骚而自断经脉。不论遇到什么事情，都要做一棵永远成长的苹果树，因为你的成长永远比每个月拿多少钱重要。

（二）动机的寓言：孩子在为谁而玩
一群孩子在一位老人家门前嬉闹，叫声连天。几天过去，老人难以忍受。
于是，他出来给了每个孩子25美分，对他们说：“你们让这儿变得很热闹，我觉得自己年轻了不少，这点钱表示谢意。”
孩子们很高兴，第二天仍然来了，一如既往地嬉闹。老人再出来，给了每个孩子15美分。他解释说，自己没有收入，只能少给一些。15美分也还可以吧，孩子仍然兴高采烈地走了。第三天，老人只给了每个孩子5美分。孩子们勃然大怒，“一天才5美分，知不知道我们多辛苦！”他们向老人发誓，他们再也不会为他玩了！

【心理点评】你在为谁而“玩”
这个寓言是苹果树寓言的更深一层的答案：苹果树为什么会自断经脉，因为它不是为自己而“玩”。
人的动机分两种：内部动机和外部动机。如果按照内部动机去行动，我们就是自己的主人。如果驱使我们的是外部动机，我们就会被外部因素所左右，成为它的奴隶。在这个寓言中，老人的算计很简单，他将孩子们的内部动机“为自己快乐而玩”变成了外部动机“为得到美分而玩”，而他操纵着美分这个外部因素，所以也操纵了孩子们的行为。寓言中的老人，像不像是你的老板、上司？而美分，像不像是你的工资、奖金等各种各样的外部奖励？
如将外部评价当作参考坐标，我们的情绪就很容易出现波动。因为，外部因素我们控制不了，它很容易偏离我们的内部期望，让我们不满，让我们牢骚满腹。不满和牢骚等负性情绪让我们痛苦，为了减少痛苦，我们就只好降低内部期望，最常见的方法就是减少工作的努力程度。一个人之所以会形成外部评价体系，最主要的原因是父母喜欢控制他。父母太喜欢使用口头奖惩、物质奖惩等控制孩子，而不去理会孩子自己的动机。久而久之，孩子就忘记了自己的原初动机，做什么都很在乎外部的评价。上学时，他忘记了学习的原初动机———好奇心和学习的快乐；工作后，他又忘记了工作的原初动机———成长的快乐，上司的评价和收入的起伏成了他工作的最大快乐和痛苦的源头。
切记：外部评价系统经常是一种家族遗传，但你完全可以打破它，从现在开始培育自己的内部评价体系，让学习和工作变成“为自己而玩”。

（三）规划的寓言：把一张纸折叠51次
想象一下，你手里有一张足够大的白纸。现在，你的任务是，把它折叠51次。那么，它有多高？一个冰箱？一层楼？或者一栋摩天大厦那么高？不是，差太多了，这个厚度超过了地球和太阳之间的距离。

【心理点评】到现在，我拿这个寓言问过十几个人了，只有两个人说，这可能是一个想象不到的高度，而其他人想到的最高的高度也就是一栋摩天大厦那么高。折叠51次的高度如此恐怖，但如果仅仅是将51张白纸叠在一起呢？这个对比让不少人感到震撼。因为没有方向、缺乏规划的人生，就像是将51张白纸简单叠在一起。今天做做这个，明天做做那个，每次努力之间并没有一个联系。这样一来，哪怕每个工作都做得非常出色，它们对你的整个人生来说也不过是简单的叠加而已。当然，人生比这个寓言更复杂一些。有些人，一生认定一个简单的方向而坚定地做下去，他们的人生最后达到了别人不可企及的高度。譬如，我一个朋友的人生方向是英语，他花了十数年努力，仅单词的记忆量就达到了十几万之，在这一点上达到了一般人无法企及的高度。也有些人，他们的人生方向也很明确，譬如开公司做老板，这样，他们就需要很多技能———专业技能、管理技能、沟通技能、决策技能等等。他们可能会在一开始尝试做做这个，又尝试做做那个，没有一样是特别精通的，但最后，开公司做老板的这个方向将以前的这些看似零散的努力统合到一起，这也是一种复杂的人生折叠，而不是简单的叠加。
切记：看得见的力量比看不见的力量更有用。现在，流行从看不见的地方寻找答案，譬如潜能开发，譬如成功学，以为我们的人生要靠一些奇迹才能得救。但是，在我看来，东莞恒缘心理咨询中心的咨询师毛正强说得更正确，“通过规划利用好现有的能力远比挖掘所谓的潜能更重要。”

（四）逃避的寓言：小猫逃开影子的招数“影子真讨厌！”小猫汤姆和托比都这样想，“我们一定要摆脱它。”然而，无论走到哪里，汤姆和托比发现，只要一出现阳光，它们就会看到令它们抓狂的自己的影子。不过，汤姆和托比最后终于都找到了各自的解决办法。汤姆的方法是，永远闭着眼睛。托比的办法则是，永远待在其他东西的阴影里。

【心理点评】这个寓言说明，一个小的心理问题是如何变成更大的心理问题的。可以说，一切心理问题都源自对事实的扭曲。什么事实呢？主要就是那些令我们痛苦的负性事件因为痛苦的体验，我们不愿意去面对这个负性事件。但是，一旦发生过，这样的负性事件就注定要伴随我们一生，我们能做的，最多不过是将它们压抑到潜意识中去，这就是所谓的忘记。但是，它们在潜意识中仍然会一如既往地发挥作用。并且，哪怕我们对事实遗忘得再厉害，这些事实所伴随的痛苦仍然会袭击我们，让我们莫名其妙地伤心难过，而且无法抑制。这种疼痛让我们进一步努力去逃避。发展到最后，通常的解决办法就是这两个：要么，我们像小猫汤姆一样，彻底扭曲自己的体验，对生命中所有重要的负性事实都视而不见；要么，我们像小猫托比一样，干脆投靠痛苦，把自己的所有事情都搞得非常糟糕，既然一切都那么糟糕，那个让自己最伤心的原初事件就不是那么疼了。
白云心理医院的咨询师李凌说，99％的吸毒者有过痛苦的遭遇。他们之所以吸毒，是为了让自己逃避这些痛苦。这就像是躲进阴影里，痛苦的事实是一个魔鬼，为了躲避这个魔鬼，干脆把自己卖给更大的魔鬼。还有很多酗酒的成人，他们有过一个酗酒而暴虐的老爸，挨过老爸的不少折磨。为了忘记这个痛苦，他们学会了同样的方法。除了这些看得见的错误方法外，我们人类还发明了无数种形形色色的方法去逃避痛苦，弗洛伊德将这些方式称为心理防御机制。太痛苦的时候，这些防御机制是必要的，但糟糕的是，如果心理防御机制对事实扭曲得太厉害，它会带出更多的心理问题，譬如强迫症、社交焦虑症、多重人格，甚至精神分裂症等。真正抵达健康的方法只有一个———直面痛苦。直面痛苦的人会从痛苦中得到许多意想不到的收获，它们最终会变成当事人的生命财富。
切记：阴影和光明一样，都是人生的财富。一个最重要的心理规律是，无论多么痛苦的事情，你都是逃不掉的。你只能去勇敢地面对它，化解它，超越它，最后和它达成和解。如果你自己暂时缺乏力量，你可以寻找帮助，寻找亲友的帮助，或寻找专业的帮助，让你信任的人陪着你一起去面对这些痛苦的事情。
美国心理学家罗杰斯曾是最孤独的人，但当他面对这个事实并化解后，他成了真正的人际关系大师；美国心理学家弗兰克有一个暴虐而酗酒的继父和一个糟糕的母亲，但当他挑战这个事实并最终从心中原谅了父母后，他成了治疗这方面问题的专家；日本心理学家森田正马曾是严重的神经症患者，但他通过挑战这个事实并最终发明出了森田疗法……他们生命中最痛苦的事实最后都变成了他们最重要的财富。你，一样也可以做到。

（五）行动的寓言———螃蟹、猫头鹰和蝙蝠
螃蟹、猫头鹰和蝙蝠去上恶习补习班。数年过后，它们都顺利毕业并获得博士学位。不过，螃蟹仍横行，猫头鹰仍白天睡觉晚上活动，蝙蝠仍倒悬。

【心理点评】这是黄永玉大师的一个寓言故事，它的寓意很简单：行动比知识重要。用到心理健康中，这个寓言也发人深省。心理学的知识堪称博大精深。但是，再多再好的心理学知识也不能自动帮助一个人变得更健康。其实，我知道的一些学过多年心理学的人士，他们学心理学的目的之一就是要治自己，但学了这么多年以后，他们的问题依旧。之所以出现这种情况，一个很重要的原因是，他们没有身体力行，那样知识就只是遥远的知识，知识并没有化成他们自己的生命体验。我的一个喜欢心理学的朋友，曾被多名心理学人士认为不敏感，不适合学心理学。但事实证明，这种揣测并不正确。他是不够敏感，但他有一个非常大的优点：知道一个好知识，就立即在自己的生命中去执行。这样一来，那些遥远的知识就变成了真切的生命体验，他不必“懂”太多，就可以帮助自己，并帮助很多人。如果说，高敏感度是一种天才素质，那么高行动力是更重要的天才素质。这个寓言还可以引申出另一种含义：不要太指望神秘的心理治疗的魔力。最重要的力量永远在你自己的身上，奥秘的知识、玄妙的潜能开发、炫目的成功学等等，都远不如你自己身上已有的力量重要。我们习惯去外面寻找答案，去别人那里寻找力量，结果忘记了力量就在自己身上。
切记：别人的知识不能自动地拯救你。如果一些连珠的妙语打动了你，如果一些文字或新信条启发了你。那么，这些别人的文字和经验都只是一个开始，更重要的是，你把你以为好的知识真正运用到你自己的生命中去。犹太哲学家马丁•布伯的这句话，我一直认为是最重要的：你必须自己开始。假如你自己不以积极的爱去深入生存，假如你不以自己的方式去为自己揭示生存的意义，那么对你来说，生存就将依然是没有意义的。

（六）放弃的寓言：蜜蜂与鲜花
玫瑰花枯萎了，蜜蜂仍拼命吮吸，因为它以前从这朵花上吮吸过甜蜜。但是，现在在这朵花上，蜜蜂吮吸的是毒汁。
蜜蜂知道这一点，因为毒汁苦涩，与以前的味道是天壤之别。于是，蜜蜂愤不过，它吸一口就抬起头来向整个世界抱怨，为什么味道变了？！
终于有一天，不知道是什么原因，蜜蜂振动翅膀，飞高了一点。这时，它发现，枯萎的玫瑰花周围，处处是鲜花。

【心理点评】这是关于爱情的寓言，是一位年轻的语文老师的真实感悟。有一段时间，她失恋了，很痛苦，一直想约我聊聊，希望我的心理学知识能给她一些帮助。我们一直约时间，但快两个月过去了，两人的时间总不能碰巧凑在一起。最后一次约她，她说：“谢谢！不用了，我想明白了。”原来，她刚从九寨沟回来。失恋的痛苦仍在纠缠她，让她神情恍惚，不能享受九寨沟的美丽。不经意的时候，她留意到一只小蜜蜂正在一朵鲜花上采蜜。那一刹那间，她脑子里电闪雷鸣般地出现了一句话：“枯萎的鲜花上，蜜蜂只能吮吸到毒汁。当然，大自然中的小蜜蜂不会这么做，只有人类才这么傻，她这句话里的蜜蜂当然指她自己。这一刹那，她顿悟出了放弃的道理。以前，她想让我帮她走出来，但翅膀其实就长在她自己身上，她想飞就能飞。放弃并不容易，爱情中的放弃尤其令人痛苦。因为，爱情是对我们幼小时候的亲子关系的复制。幼小的孩子，无论从哪个方面看，都离不开爸爸妈妈。如果爸爸妈妈完全否定他，那对他来说就意味着死亡，这是终极的伤害和恐惧。我们多多少少都曾体验过被爸爸妈妈否定的痛苦和恐惧，所以，当爱情———这个亲子关系的复制品再一次让我们体验这种痛苦和恐惧时，我们的情绪很容易变得非常糟糕。不过，爱情和亲子关系相比，有一个巨大的差别：小时候，我们无能为力，一切都是父母说了算；但现在，我们长大了，我们有力量自己去选择自己的命运。可以说，童年时，我们是没有翅膀的小蜜蜂，但现在，我们有了一双强有力的翅膀了。但是，当深深地陷入爱情时，我们会回归童年，我们会忘记自己有一双可以飞翔的翅膀。等我们自己悟出这一点后，爱情就不再会是对亲子关系的自动复制，我们的爱情就获得了自由，就有了放弃的力量。
切记：爱情是两个人的事情，两个完全平等的、有独立人格的人的事情。你可以努力，但不是说，你努力了就一定会有效果，因为另一个人，你并不能左右。所以，无论你多么在乎一次爱情，如果另一个人坚决要离开你，请尊重他的选择。并且，还要记得，你不再是童年，只能听凭痛苦的折磨。你已成人，你有一双强有力的翅膀，你完全可以飞出一个已经变成毒药的关系。

第一种，知识陈旧的人。

如今，知识更新的速度越来越快，知识倍增的周期越来越短。２０世纪６０年代，知识倍增，周期是８年，７０年代减少为６年，８０年代缩短成３年，进入９０年代以后，更是１年就增长１倍。人类真正进入了知识爆炸的时代，现有知识每年在以１０％的速度更新。生活在这样一个时代，任何人都必须不断学习，更新知识，想靠学校学的知识“应付”一辈子，已完全不可能了。过去，我们对“终身教育”的理解是，一个人从上学到退休，要一直接受教育；现在，这一概念应当重新定义，终身教育，从摇篮到坟墓，应贯穿人的一生。那些“抱残守缺”、知识陈旧的人，将是职场中的麻烦人。

第二种，技能单一的人。

只会做一种工作，换一个岗位就不“灵光”的人，日子会不好过。将来竞争会越来越激烈，就业?下岗?再就业?再下岗，将成为司空见惯的事。要想避免在职场中成为“积压物资”，唯一的办法就是多学几手，一专多能。只有这样，才不至于“一棵树上吊死”，一旦下岗，心中不慌，“此处不留人，自有留人处”。如果说，入世后，复合型人才大受欢迎的话，技能单一的人遭到冷遇，就是非常自然的事了。　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

第三种，情商低下的人。

智商显示一个人做事的本领，情商反映一个人做人的表现。在未来社会，不仅要会做事，更要会做人。情商高的人，说话得体，办事得当，才思敏捷，“人见人爱”。情商低的人，不是“不合群”，就是“讨人嫌”，要不就是“哪壶不开提哪壶”，这就麻烦了。现在，在国外广为流传这样的话：“靠智商得到录用，靠情商得到提拔。”一旦进入一个单位，能不能“工作顺利”、“事业有成”，情商是一个关键因素。吴德贵向职场中人提出善意忠告，在不断提升自己的能力时，还应不断培养自己的情商。否则，“身怀绝技”，也难免“碰壁”。　　

第四种，心理脆弱的人。

遇到一点困难，就打“退堂鼓”，稍有不顺利，情绪就降到“.”，这样的人，在今后的激烈竞争中必然日子不好过。由于生活节奏加快，竞争压力加大，有“心理障碍”或“心理疾病”的人逐渐增多，神经紧张、心理脆弱成了都市“现代病”。因此，入世后，无论在职者，还是求职者，都应该增强心理承受能力，提高“抗挤”、“抗压”素质。吴德贵说，在当今社会，没有一股不服输的“犟劲”，没有一种不怕难的“韧劲”，是不行的。　　　　　　　　　　　　　　　　　　　　　　　

第五种，目光短浅的人。

鼠目寸光难成大事，目光远大可成大器。有句话说得好：“你能看多远，你便能走多远。”一个组织的成长，需要规划，一个人的成长，需要设计。吴德贵说，有生涯设计的人，未必肯定成功，没有生涯设计的人，一定很难成功。“过一天算一天”，“哪里黑哪里住”，只看见鼻尖下边一小块地方的人，现在“不吃香”，以后更“不吃香”。

第六种，反应迟钝的人。

当今社会，“迟钝”就会“迟缓”，落后就要挨打。过去是“大鱼吃小鱼”，如今是“快鱼吃慢鱼”。入世后，一个人如果“思维”不“敏捷”，“反映”不“快速”，墨守成规，四平八稳，迟早会被淘汰。

第七种，单打独斗人。

“学科交*、知识融会、技术集成”的现实告诉我们，在当今这个国际经济大循环的世界里，“孤胆英雄”的时代已经过去，个人的作用在下降，群体的作用在上升。要成就一项事业，靠个把人、少数人是不行的，需要一支队伍，一个组织，一个群体的共同奋斗，需要众多人智慧碰撞，团队合作。“跑单帮”难成气候，“抱成团”才能打出一片天地。

第八种，不善学习的人。

有些人虽然也想学习，但是不知道学习的方法，不掌握学习的技术。这种人今后肯定“吃亏”。处在当今这个学习型社会里，人与人之间的差异，主要是学习能力的差异；人与人之间的“较量”，关键在学习能力的“较量”。过去，我们把不识字称之为“文盲”，未来学家托夫勒说，未来的“文盲”是想学习而不会学习的人。