Generating stock prices using geometric brownian motion
This looks like a really interesting use of Brownian motion! Neat idea! Here are some suggestions for improving the code:
Avoid using namespace std
In general, using using namespace std is a bad idea. In a header, it's a very bad idea. Here's one description of why.
Naming
You should name your function arguments in the header so a user of your code knows what they represent. For example, in the future, you might compile this into a library to include in other programs, and ship just the header and the compiled library. If you do that, a user of your library will have no idea what the arguments to the LSM constructor are. (And remember that that user may be a future you who doesn't remember all the details of the implementation!)
I'd also recommend that you use better names than 1 letter names that may be meaningless or worse, confusing to readers of your code. You have some great ideas for what the names should be in the comments in main(). Instead of adding comments to explain the names, just name the variables what you wrote in the comments. For example, instead of r, call it risklessInterestRate. Instead of q, call it dividendYield. Yes, it takes a little bit longer to type, but those few extra seconds of typing will end up saving minutes or hours of frustration if you get 2 of the variables with similar names confused (like M and N).
Headers
Only include what you need. Only include it where you need it. Your main() function doesn't need any header other than LSM.h, so it should be the only thing you include there. LSM.h doesn't need any of the files it has included except for &lt;vector&gt;. LSM.cpp should include those files instead because it does use them. It might not seem like a big deal now, but once your project gets a little bigger, including the wrong files or including files you don't need can really slow down a compile.
Constructors
In C++, the constructor should never call a virtual method of its own class because it's not yet fully constructed. Luckily your code does not do that. But it does call a non-virtual method. When I see that, it raises a red flag to me, because it's fairly common for a non-virtual method to later become virtual if a subclass needs to override it. For that reason, I tend to avoid calling any (non-static) methods of the same class within a constructor. Furthermore, the LSM::GBM function doesn't use any member variables or change any state in the object or call any member functions of LSM, so it could be implemented as a free-standing static function inside LSM.cpp. (Unless, of course, you're going to want other code outside the class to call it, in which case it should probably be a static member function of the LSM class.)
const
Nice use of const! So few people use it, so it's really refreshing to see it being used well. Good work!